%%	-*- erlang -*-
%%
%% %CopyrightBegin%
%%
%% Copyright Ericsson AB 2008-2023. All Rights Reserved.
%%
%% Licensed under the Apache License, Version 2.0 (the "License");
%% you may not use this file except in compliance with the License.
%% You may obtain a copy of the License at
%%
%%     http://www.apache.org/licenses/LICENSE-2.0
%%
%% Unless required by applicable law or agreed to in writing, software
%% distributed under the License is distributed on an "AS IS" BASIS,
%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
%% See the License for the specific language governing permissions and
%% limitations under the License.
%%
%% %CopyrightEnd%
%
%% Api defs file, defines the classes and members we want.

%% {class,wxObject,Options,[Function|{Func,Opt}]}.
%% {enum, Type, SkipPart}

{const_skip, [wxGenericFindReplaceDialog, wxInvalidDateTime, wxLANGUAGE_KHMER]}.
{not_const,
 [wxRETAINED,
  wxFONTENCODING_UTF32,wxFONTENCODING_UTF16, wxFONTENCODING_UNICODE,
  wxDEFAULT_CONTROL_BORDER,
  wxTBI_DEFAULT_TYPE,
  wxTB_DEFAULT_STYLE,
  wxMAJOR_VERSION, wxMINOR_VERSION,
  wxRELEASE_NUMBER,wxSUBRELEASE_NUMBER,wxBETA_NUMBER,
  %%
  wxID_AUTO_LOWEST,
  'WXK_RAW_CONTROL',
  wxMOD_RAW_CONTROL,
  wxACCEL_RAW_CTRL,

  wxALWAYS_NATIVE_DOUBLE_BUFFER,
  wxTR_DEFAULT_STYLE,
  wxDIRP_DEFAULT_STYLE,
  wxFLP_DEFAULT_STYLE,

  wxSL_LABELS,
  wxCURSOR_DEFAULT,
  wxCURSOR_ARROWWAIT,
  wxCURSOR_MAX,
  wxLanguage,
  wxFONTWEIGHT_NORMAL,
  wxFONTWEIGHT_LIGHT,
  wxFONTWEIGHT_BOLD,
  wxFONTWEIGHT_MAX,
  wxFD_MULTIPLE,

  wxBackgroundStyle,
  wxIMAGE_QUALITY_NORMAL,
  wxIMAGE_QUALITY_HIGH,
  wxIMAGE_QUALITY_NEAREST,
  wxIMAGE_QUALITY_BILINEAR,
  wxIMAGE_QUALITY_BICUBIC,
  wxIMAGE_QUALITY_BOX_AVERAGE,

  %% Differ 3.0 and 3.1
  wxBK_HITTEST_ONITEM,
  wxCAL_SUNDAY_FIRST,
  wxWS_EX_VALIDATE_RECURSIVELY,

  %% Kept for backward compat
  wxBG_STYLE_CUSTOM,

  %% New enums needed for gl contexts not static numbers
  {'wx_GL_COMPAT_PROFILE',   {test_if, "wxCHECK_VERSION(3,1,0)"}},
  {'WX_GL_FORWARD_COMPAT',   {test_if, "wxCHECK_VERSION(3,1,0)"}},
  {'WX_GL_ES2',              {test_if, "wxCHECK_VERSION(3,1,0)"}},
  {'WX_GL_DEBUG',            {test_if, "wxCHECK_VERSION(3,1,0)"}},
  {'WX_GL_ROBUST_ACCESS',    {test_if, "wxCHECK_VERSION(3,1,0)"}},
  {'WX_GL_NO_RESET_NOTIFY',  {test_if, "wxCHECK_VERSION(3,1,0)"}},
  {'WX_GL_LOSE_ON_RESET',    {test_if, "wxCHECK_VERSION(3,1,0)"}},
  {'WX_GL_RESET_ISOLATION',  {test_if, "wxCHECK_VERSION(3,1,0)"}},
  {'WX_GL_RELEASE_FLUSH',    {test_if, "wxCHECK_VERSION(3,1,0)"}},
  {'WX_GL_RELEASE_NONE',     {test_if, "wxCHECK_VERSION(3,1,0)"}},
  {'WX_GL_FRAMEBUFFER_SRGB', {test_if, "wxCHECK_VERSION(3,1,0)"}},

  %% Added (enum) values in 3.1.2
  {wxFONTWEIGHT_INVALID, {test_if, "wxCHECK_VERSION(3,1,2)"}},
  {wxFONTWEIGHT_THIN, {test_if, "wxCHECK_VERSION(3,1,2)"}},
  {wxFONTWEIGHT_EXTRALIGHT, {test_if, "wxCHECK_VERSION(3,1,2)"}},
  {wxFONTWEIGHT_MEDIUM, {test_if, "wxCHECK_VERSION(3,1,2)"}},
  {wxFONTWEIGHT_SEMIBOLD, {test_if, "wxCHECK_VERSION(3,1,2)"}},
  {wxFONTWEIGHT_EXTRABOLD, {test_if, "wxCHECK_VERSION(3,1,2)"}},
  {wxFONTWEIGHT_HEAVY, {test_if, "wxCHECK_VERSION(3,1,2)"}},
  {wxFONTWEIGHT_EXTRAHEAVY, {test_if, "wxCHECK_VERSION(3,1,2)"}},

  {wxGRADIENT_, {test_if, "wxCHECK_VERSION(3,1,3)"}},
  {wxGA_PROGRESS, {test_if, "wxCHECK_VERSION(3,1,0)"}},
  {wxGA_TEXT, {test_if, "wxCHECK_VERSION(3,1,0)"}},

  {wxCLRP_SHOW_ALPHA, {test_if, "wxCHECK_VERSION(3,1,0)"}},

  {wxFD_NO_FOLLOW, {test_if, "wxCHECK_VERSION(3,1,0)"}},
  {wxFD_SHOW_HIDDEN, {test_if, "wxCHECK_VERSION(3,1,3)"}},
  {wxDD_SHOW_HIDDEN, {test_if, "wxCHECK_VERSION(3,1,4)"}},
  {wxDD_MULTIPLE, {test_if, "wxCHECK_VERSION(3,1,4)"}},
  {wxDIRCTRL_DEFAULT_STYLE, {test_if, "wxCHECK_VERSION(3,1,1)"}},

  'WXK_SPECIAL',  %% Varies in 3.0.4 and 3.1
  {'WXK_BROWSER', {test_if, "wxCHECK_VERSION(3,1,0)"}},
  {'WXK_VOLUME',  {test_if, "wxCHECK_VERSION(3,1,0)"}},
  {'WXK_MEDIA',   {test_if, "wxCHECK_VERSION(3,1,0)"}},
  {'WXK_LAUNCH',  {test_if, "wxCHECK_VERSION(3,2,0)"}},

  %% Varies in 3.1 and 3.2
  wxDF_MAX,

  {wxTOUCH, {test_if, "wxCHECK_VERSION(3,1,1)"}},

  {'wxHtmlEasyPrinting::Prompt', {test_if, "wxCHECK_VERSION(3,1,2)"}},
  {'wxStaticBitmap::Scale_', {test_if, "wxCHECK_VERSION(3,1,0)"}},
  {wxSYS_CARET_, {test_if, "wxCHECK_VERSION(3,1,1)"}},

  {wxStrip_CJKM, {test_if, "wxCHECK_VERSION(3,1,3)"}},
  {wxStrip_Menu, {test_if, "wxCHECK_VERSION(3,1,3)"}},

  {wxPU_CONTAINS_CONTROLS, {test_if, "wxCHECK_VERSION(3,1,3)"}},

  wxTEXT_ATTR_ALL,
  wxTEXT_ATTR_PARAGRAPH,
  {wxTEXT_ATTR_UNDERLINE, {test_if, "wxCHECK_VERSION(3,1,3)"}},
  {wxTEXT_ATTR_AVOID_PAGE, {test_if, "wxCHECK_VERSION(3,1,3)"}},
  {wxTEXT_ATTR_EFFECT_RTL, {test_if, "wxCHECK_VERSION(3,1,3)"}},
  {wxTEXT_ATTR_EFFECT_SUPPRESS, {test_if, "wxCHECK_VERSION(3,1,3)"}},

  {wxXRC_USE_ENVVARS, {test_if, "wxCHECK_VERSION(3,1,3)"}},

  %% Many changes in wxSTC (styled textctrl)
  {wxSTC_ABL_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_AC_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_ANNOTATION_INDENTED, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_AUTO, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_B_,   {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_BAAN_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_BIBTEX_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_C_ESCAPESEQ, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_C_PREPROCESSORCOMMENTDOC, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_C_TASKMARKER, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_C_USERLITERAL, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_CASE_CAMEL, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_CHARSET_OEM866, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_CMD_VCHOMEDISPLAY, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_COFFEESCRIPT_INSTANCEPROPERTY, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_DMAP_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_DMIS_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_EDGE_MULTILINE, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_EDI_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_ERR_ES_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_ERR_ESC, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_ERR_GCC_INCLUDED, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_FOLDACTION_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_FOLDDISPLAY, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_FOLDFLAG_LINESTATE, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_HA_LITERATE_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_HA_PRAGMA, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_HA_PREP, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_HA_RESERVED, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_HA_STRINGEOL, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_HEX_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_IDLESTYLING_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_IME_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_INDICFLAG, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_INDICVALUE, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_INDIC_COMPOS, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_INDIC_FULLBOX, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_INDIC_IME, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_INDIC_POINT, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_INDIC_SQUIGGLE, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_INDIC_TEXTFORE, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_JSON_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_KEYMOD_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_KVIRC_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_KIX_COMMENTSTREAM, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_LEX_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_LINE_END_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_MARGIN_COLOUR, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_MARK_BOOKMARK, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_MAX_MARGIN, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_MOD_CHANGETABSTOPS, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_MOD_INSERTCHECK, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_MULTIAUTOC_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_MYSQL_PLACE, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_ORDER_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_PHASES_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_PO_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_POPUP_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_POWERSHELL_COMMENTDOC, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_POWERSHELL_HERE_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_REG_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_RUST_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_SQL_QOP, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_STATUS_WARN_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_STTXT_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_STYLE_FOLDDISPLAY, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_TEHEX_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_TD_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_VS_, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_V_COMMENT_WORD, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_V_IN, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_V_OUT, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_V_PORT, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_VHDL_BLOCK_COMMENT, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_WRAP_WHITESPACE, {test_if, "wxCHECK_VERSION(3,1,1)"}},
  {wxSTC_WS_VISIBLEONLYIN, {test_if, "wxCHECK_VERSION(3,1,1)"}},

  {wxWebViewZoom, {test_if, "WXE_WEBVIEW"}},
  {wxWebViewZoomType, {test_if, "WXE_WEBVIEW"}},
  {wxWebViewNavigationError, {test_if, "WXE_WEBVIEW"}},
  {wxWebViewReloadFlags, {test_if, "WXE_WEBVIEW"}},
  {wxWebViewFindFlags, {test_if, "WXE_WEBVIEW"}},
  {wxWebViewNavigationActionFlags, {test_if, "WXE_WEBVIEW && wxCHECK_VERSION(3,1,2)"}},
  {wxWebViewIE_EmulationLevel, {test_if, "WXE_WEBVIEW_IE && wxCHECK_VERSION(3,1,3)"}}
 ]}.

{gvars,
 [
  {wxITALIC_FONT, wxFont},
  {wxNORMAL_FONT, wxFont},
  {wxSMALL_FONT,  wxFont},
  {wxSWISS_FONT,  wxFont},

  {wxBLACK_DASHED_PEN, wxPen},
  {wxBLACK_PEN, wxPen},
  {wxCYAN_PEN, wxPen},
  {wxGREEN_PEN, wxPen},
  {wxGREY_PEN, wxPen},
  {wxLIGHT_GREY_PEN, wxPen},
  {wxMEDIUM_GREY_PEN, wxPen},
  {wxRED_PEN, wxPen},
  {wxTRANSPARENT_PEN, wxPen},
  {wxWHITE_PEN, wxPen},

  {wxBLACK_BRUSH, wxBrush},
  {wxBLUE_BRUSH, wxBrush},
  {wxCYAN_BRUSH, wxBrush},
  {wxGREEN_BRUSH, wxBrush},
  {wxGREY_BRUSH, wxBrush},
  {wxLIGHT_GREY_BRUSH, wxBrush},
  {wxMEDIUM_GREY_BRUSH, wxBrush},
  {wxRED_BRUSH, wxBrush},
  {wxTRANSPARENT_BRUSH, wxBrush},
  {wxWHITE_BRUSH, wxBrush},

  {wxCROSS_CURSOR, wxCursor},
  {wxHOURGLASS_CURSOR, wxCursor},
  {wxSTANDARD_CURSOR, wxCursor},

  {wxBLACK, wxColour},
  {wxBLUE,  wxColour},
  {wxCYAN,  wxColour},
  {wxGREEN, wxColour},
  {wxLIGHT_GREY, wxColour},
  {wxRED,   wxColour},
  {wxWHITE, wxColour},

  {wxNullBitmap,     {address,wxBitmap}},
  {wxNullIcon,       {address,wxIcon}},
  {wxNullCursor,     {address,wxCursor}},
  {wxNullPen,        {address,wxPen}},
  {wxNullBrush,      {address,wxBrush}},
  {wxNullPalette,    {address,wxPalette}},
  {wxNullFont,       {address,wxFont}},

  {'WX_GL_CORE_PROFILE',     {test_if, "wxCHECK_VERSION(3,0,3)"}},
  {'WX_GL_MAJOR_VERSION',    {test_if, "wxCHECK_VERSION(3,0,3)"}},
  {'WX_GL_MINOR_VERSION',    {test_if, "wxCHECK_VERSION(3,0,3)"}}

 ]}.

{enum, wxBackgroundStyle, "wxBG_STYLE_"}.
{enum, wxWindowVariant, "wxWINDOW_VARIANT_"}.
{enum, wxBitmapType, "wxBITMAP_TYPE_"}.
{enum, wxMouseWheelAxis, "wxMOUSE_WHEEL_"}.

{class, wxeEvtHandler, object, [taylormade, {alias, [{wxeEvtHandler, wxEvtHandler}]}],
 [{'Connect',   [{"eventType",{base,eventType}},{"userData",nowhere}]},
  {'Disconnect',[{"eventType",{base,eventType}},{"userData",nowhere}]}]
}.

{class, wxWindow, wxEvtHandler,
 [],
 [wxWindow,'~wxWindow', %% 'AddChild',
  'Create',
  'CacheBestSize','CaptureMouse',
  {'Centre',[{erl_alias, 'Center'}]},
  {'CentreOnParent',[{erl_alias, 'CenterOnParent'}]},
  'ClearBackground',
  {'ClientToScreen',[{"x",both},{"y",both}]}, 'Close',
  'ConvertDialogToPixels','ConvertPixelsToDialog','Destroy','DestroyChildren',
  'Disable',%%'DoGetBestSize','DoUpdateWindowUI',
  'DragAcceptFiles',
  'Enable',
  'FindFocus','FindWindow','FindWindowById','FindWindowByName','FindWindowByLabel',
  'Fit','FitInside','Freeze', 'GetAcceleratorTable', % 'GetAccessible',
  'GetBackgroundColour','GetBackgroundStyle',
  'GetBestSize','GetCaret','GetCapture','GetCharHeight',
  'GetCharWidth','GetChildren',
  %%'GetClassDefaultAttributes','GetConstraints'
  'GetClientSize','GetContainingSizer','GetCursor',
  %%'GetDefaultAttributes',
  'GetDropTarget', %% 'GetEventHandler',
  {'GetDPIScaleFactor', [{test_if, "wxCHECK_VERSION(3,1,4)"}]},
  'GetExtraStyle','GetFont','GetForegroundColour',
  'GetGrandParent',
  {'GetHandle', [{return, [{type,"wxUIntPtr"}, {ref,pointer}, {base, int}]}]},
  'GetHelpText','GetId','GetLabel','GetMaxSize',
  'GetMinSize','GetName','GetParent','GetPosition','GetRect',
  {'GetScreenPosition', [{"x",out},{"y",out}]}, 'GetScreenRect',
  'GetScrollPos','GetScrollRange','GetScrollThumb','GetSize','GetSizer',
  {'GetTextExtent', [{"descent", out}, {"externalLeading", out}]},
  'GetThemeEnabled',
  'GetToolTip','GetUpdateRegion',%'GetValidator',
  'GetVirtualSize','GetWindowStyleFlag','GetWindowVariant','HasCapture','HasScrollbar',
  'HasTransparentBackground','Hide','InheritAttributes','InitDialog',
  'InvalidateBestSize', 'IsFrozen',
  'IsEnabled','IsExposed','IsRetained','IsShown','IsTopLevel',
  'IsShownOnScreen',
  'Layout','LineDown','LineUp','Lower', %% 'MakeModal', buggy and deprecated
  'Move','MoveAfterInTabOrder',
  'MoveBeforeInTabOrder','Navigate',%'OnInternalIdle',
  'PageDown','PageUp',
  %% 'PopEventHandler',
  'PopupMenu',%'PushEventHandler',
  'Raise', 'Refresh', 'RefreshRect',%'RegisterHotKey',
  'ReleaseMouse','RemoveChild',%'RemoveEventHandler',
  'Reparent',
  'ScreenToClient','ScrollLines','ScrollPages','ScrollWindow','SetAcceleratorTable',
  %%'SetAccessible',
  'SetAutoLayout','SetBackgroundColour','SetBackgroundStyle',
  'SetCaret','SetClientSize','SetContainingSizer','SetCursor',
  %%'SetConstraints','SetInitialBestSize',
  'SetMaxSize','SetMinSize',
  'SetOwnBackgroundColour','SetOwnFont','SetOwnForegroundColour','SetDropTarget',
  %%'SetEventHandler',
  'SetExtraStyle','SetFocus','SetFocusFromKbd','SetFont',
  'SetForegroundColour','SetHelpText','SetId','SetLabel','SetName','SetPalette',
  'SetScrollbar','SetScrollPos','SetSize','SetSizeHints','SetSizer','SetSizerAndFit',
  'SetThemeEnabled','SetToolTip',%'SetValidator',
  'SetVirtualSize', %% 'SetVirtualSizeHints',  no-op and deprecated
  'SetWindowStyle','SetWindowStyleFlag','SetWindowVariant',
  'ShouldInheritColours','Show','Thaw','TransferDataFromWindow',
  'TransferDataToWindow',%'UnregisterHotKey',
  'Update','UpdateWindowUI','Validate',
  'WarpPointer',
  'SetTransparent',
  'CanSetTransparent',
  'IsDoubleBuffered',
  {'SetDoubleBuffered', [{test_if, "wxCHECK_VERSION(3,1,0) || (!defined(__WXMAC__) && wxCHECK_VERSION(3,0,0))"}]},
  'GetContentScaleFactor',
  {'GetDPI', [{test_if, "wxCHECK_VERSION(3,1,3)"}]},
  {'FromDIP', [{test_if, "wxCHECK_VERSION(3,1,0)"}]},
  {'ToDIP', [{test_if, "wxCHECK_VERSION(3,1,0)"}]}

]}.

{class, wxTopLevelWindow, wxWindow,
 [{alias, [{wxTopLevelWindowGTK, wxTopLevelWindow}]}],
 [{'GetIcon', [{return, {by_val, true}}]},
  'GetIcons','GetTitle','IsActive','Iconize',
  'IsFullScreen','IsIconized','IsMaximized','Maximize',
  'RequestUserAttention','SetIcon','SetIcons',
  {'CentreOnScreen', [{erl_alias, 'CenterOnScreen'}]},
  %%'SetLeftMenu', 'SetRightMenu',
  'SetShape','SetTitle','ShowFullScreen'
 ]}.

{class, wxFrame, wxTopLevelWindow, [],
 ['wxFrame','~wxFrame',%'Centre',
  'Create','CreateStatusBar','CreateToolBar',
  'GetClientAreaOrigin','GetMenuBar','GetStatusBar','GetStatusBarPane',
  'GetToolBar',%'OnCreateStatusBar','OnCreateToolBar',
  'ProcessCommand','SendSizeEvent','SetMenuBar','SetStatusBar',
  'SetStatusBarPane','SetStatusText',
  {'SetStatusWidths', [{"n",{c_only,{length,"widths_field"}}}]},
  'SetToolBar']}.

{class, wxMiniFrame, wxFrame, [],
 ['wxMiniFrame','~wxMiniFrame','Create']}.

%% Hmm what do we do with these
%% {class, wxValidator, root,[],
%%  ['wxValidator','~wxValidator','Clone','GetWindow','SetBellOnError','SetWindow',
%%   'TransferFromWindow','TransferToWindow','Validate']}.
%% {class, wxGenericValidator, wxValidator,[],
%%  ['wxGenericValidator','~wxGenericValidator','Clone',
%%   'TransferFromWindow','TransferToWindow']}.
%% {class, wxTextValidator, wxValidator,[],
%%  ['wxTextValidator','Clone','GetExcludes','GetIncludes','GetStyle',
%%   'OnChar','SetExcludes','SetIncludes','SetStyle','TransferFromWindow',
%%   'TransferToWindow','Validate']}.

{class, wxSplashScreen, wxFrame, [], 
 ['wxSplashScreen','~wxSplashScreen',%'OnCloseWindow',
  'GetSplashStyle', %'GetSplashWindow',
  'GetTimeout']}.

{class, wxPanel, wxWindow, [],
 ['wxPanel','~wxPanel',%'Create',
  %%'GetDefaultItem',
  'InitDialog',
  %%'OnSysColourChanged', %'SetDefaultItem','SetFocus',
  'SetFocusIgnoringChildren'
 ]}.

{class, wxScrolledWindow, wxPanel, [{template, "wxScrolled"}],
 ['wxScrolled','~wxScrolled',
  'CalcScrolledPosition','CalcUnscrolledPosition',%'Create',
  'EnableScrolling','GetScrollPixelsPerUnit','GetViewStart',
  %%'GetVirtualSize','IsRetained',
  'DoPrepareDC',%'OnDraw',
  'PrepareDC','Scroll','SetScrollbars',
  'SetScrollRate',{'SetTargetWindow',[{"pushEventHandler", nowhere}]}]}.

{class, wxSashWindow, wxWindow, [],
 ['wxSashWindow','~wxSashWindow','GetSashVisible','GetMaximumSizeX',
  'GetMaximumSizeY','GetMinimumSizeX','GetMinimumSizeY',
  'SetMaximumSizeX','SetMaximumSizeY','SetMinimumSizeX','SetMinimumSizeY',
  'SetSashVisible'
 ]}.

{class, wxSashLayoutWindow, wxSashWindow, [],
 ['wxSashLayoutWindow','Create','GetAlignment','GetOrientation',
  %% 'OnCalculateLayout','OnQueryLayoutInfo', Requires events for overloading ?
  'SetAlignment','SetDefaultSize','SetOrientation'
 ]}.

{enum, {"wxGrid","wxGridSelectionModes"}, "wxGrid::wxGrid"}.
{class, wxGrid, wxScrolledWindow, [],
 ['wxGrid','~wxGrid','AppendCols','AppendRows','AutoSize',%'AutoSizeColOrRow',
  'AutoSizeColumn','AutoSizeColumns','AutoSizeRow','AutoSizeRows','BeginBatch',
  {'BlockToDeviceRect', [{"gridWindow", nowhere}]},
  'CanDragCell', 'CanDragColMove', {'CanDragGridRowEdges', [{test_if, "wxCHECK_VERSION(3,1,4)"}]},
  'CanDragColSize','CanDragRowSize','CanDragGridSize',
  'CanEnableCellControl',%'CanHaveAttributes',
  'CellToRect','ClearGrid','ClearSelection','CreateGrid',
  'DeleteCols','DeleteRows','DisableCellEditControl',
  'DisableDragColSize','DisableDragGridSize','DisableDragRowSize',
  'EnableCellEditControl','EnableDragColSize','EnableDragGridSize',
  'EnableDragRowSize','EnableEditing','EnableGridLines','EndBatch','Fit',
  'ForceRefresh','GetBatchCount','GetCellAlignment','GetCellBackgroundColour',
  'GetCellEditor','GetCellFont','GetCellRenderer','GetCellTextColour','GetCellValue',
						%'GetColLeft',
  'GetColLabelAlignment','GetColLabelSize','GetColLabelValue',
  'GetColMinimalAcceptableWidth',%'GetColMinimalWidth',
						%'GetColRight','GetColSize',
  'GetDefaultCellAlignment','GetDefaultCellBackgroundColour','GetDefaultCellFont',
  'GetDefaultCellTextColour','GetDefaultColLabelSize','GetDefaultColSize',
  'GetDefaultEditor','GetDefaultEditorForCell','GetDefaultEditorForType',
  'GetDefaultRenderer','GetDefaultRendererForCell','GetDefaultRendererForType',
  'GetDefaultRowLabelSize','GetDefaultRowSize','GetGridCursorCol','GetGridCursorRow',
  'GetGridLineColour','GridLinesEnabled','GetLabelBackgroundColour','GetLabelFont',
  'GetLabelTextColour','GetNumberCols','GetNumberRows','GetOrCreateCellAttr',
  'GetRowMinimalAcceptableHeight',%'GetRowMinimalHeight',
  'GetRowLabelAlignment',
  'GetRowLabelSize','GetRowLabelValue','GetRowSize','GetScrollLineX','GetScrollLineY',
						%'GetSelectionMode',
  'GetSelectedCells','GetSelectedCols','GetSelectedRows',
  'GetSelectionBackground','GetSelectionBlockTopLeft','GetSelectionBlockBottomRight',
  'GetSelectionForeground',%'GetTable',
  'GetGridWindow', 'GetGridRowLabelWindow', 
  'GetGridColLabelWindow', 'GetGridCornerLabelWindow', 
  'HideCellEditControl',
						%'InitColWidths','InitRowHeights',
  'InsertCols','InsertRows',
  'IsCellEditControlEnabled','IsCurrentCellReadOnly','IsEditable','IsInSelection',
  'IsReadOnly','IsSelection','IsVisible','MakeCellVisible','MoveCursorDown',
  'MoveCursorLeft','MoveCursorRight','MoveCursorUp','MoveCursorDownBlock',
  'MoveCursorLeftBlock','MoveCursorRightBlock','MoveCursorUpBlock','MovePageDown',
  'MovePageUp','RegisterDataType','SaveEditControlValue','SelectAll','SelectBlock',
  'SelectCol', %'SelectionToDeviceRect',
  'SelectRow','SetCellAlignment',
  'SetCellBackgroundColour','SetCellEditor','SetCellFont','SetCellRenderer',
  'SetCellTextColour','SetCellValue','SetColAttr','SetColFormatBool',
  'SetColFormatNumber','SetColFormatFloat','SetColFormatCustom',
  'SetColLabelAlignment','SetColLabelSize','SetColLabelValue','SetColMinimalWidth',
  'SetColMinimalAcceptableWidth','SetColSize','SetDefaultCellAlignment',
  'SetDefaultCellBackgroundColour','SetDefaultCellFont','SetDefaultCellTextColour',
  'SetDefaultEditor','SetDefaultRenderer','SetDefaultColSize','SetDefaultRowSize',
  'SetGridCursor','SetGridLineColour','SetLabelBackgroundColour','SetLabelFont',
  'SetLabelTextColour','SetMargins',%'SetOrCalcColumnSizes','SetOrCalcRowSizes',
  'SetReadOnly','SetRowAttr','SetRowLabelAlignment','SetRowLabelSize',
  'SetRowLabelValue','SetRowMinimalHeight','SetRowMinimalAcceptableHeight',
  'SetRowSize','SetScrollLineX','SetScrollLineY','SetSelectionBackground',
  'SetSelectionForeground','SetSelectionMode',%'SetTable',
  'ShowCellEditControl',{'XToCol', [{"gridWindow", nowhere}]},
  'XToEdgeOfCol','YToEdgeOfRow', {'YToRow', [{"gridWindow", nowhere}]}]}.

{class, wxGridCellRenderer, root, [], 
 ['Draw','GetBestSize']}.
{class, wxGridCellEditor,   root, [], 
 ['Create',
  'IsCreated', 'SetSize', 'Show',
  %% 'PaintBackground', 'BeginEdit', {'EndEdit', [{"newval", [in]}]},  Callbacks FIXME
  'Reset', 'StartingKey',
  'StartingClick', 'HandleReturn'
  %'Destroy','Clone','~wxGridCellEditor',
 ]}.

{class, wxGridCellBoolRenderer, wxGridCellRenderer, [], 
 ['wxGridCellBoolRenderer']}.
{class, wxGridCellBoolEditor,   wxGridCellEditor, [], 
 ['wxGridCellBoolEditor', 'IsTrueValue', 'UseStringValues']}.

{class, wxGridCellFloatRenderer,  wxGridCellStringRenderer, [], 
 ['wxGridCellFloatRenderer', 'GetPrecision',  'GetWidth',
  'SetParameters', 'SetPrecision', 'SetWidth']}.
{class, wxGridCellFloatEditor,  wxGridCellEditor, [], 
 ['wxGridCellFloatEditor', 'SetParameters' ]}.

{class, wxGridCellStringRenderer,  wxGridCellRenderer, [], ['wxGridCellStringRenderer']}.
{class, wxGridCellTextEditor,   wxGridCellEditor, [], 
 ['wxGridCellTextEditor','SetParameters']}.
{class, wxGridCellChoiceEditor,   wxGridCellEditor, [{skip, [{'wxGridCellChoiceEditor', 3}]}], 
 ['wxGridCellChoiceEditor','SetParameters']}.

{class, wxGridCellNumberRenderer,  wxGridCellStringRenderer, [], 
 ['wxGridCellNumberRenderer']}.
{class, wxGridCellNumberEditor,   wxGridCellTextEditor, [], 
 ['wxGridCellNumberEditor','GetValue','SetParameters']}.

{class, wxGridCellAttr, root, [], 
 [%'wxGridCellAttr','Clone','IncRef','DecRef',
  'SetTextColour','SetBackgroundColour','SetFont','SetAlignment','SetReadOnly',
  'SetRenderer','SetEditor','HasTextColour','HasBackgroundColour','HasFont',
  'HasAlignment','HasRenderer','HasEditor','GetTextColour','GetBackgroundColour',
  'GetFont','GetAlignment','GetRenderer','GetEditor','IsReadOnly','SetDefAttr']}.

{enum, wxDirection, "wx"}.
{enum, wxLayoutDirection, "wxLayout_"}.

{class, wxDC, object, 
 [{skip, [{'DrawEllipse',5},{'DrawRectangle',5},
	  {'DrawRoundedRectangle',6},{'SetClippingRegion',5}]}],
 [{{'Blit',7},[{"rop", [{base, {enum, "wxRasterOperationMode"}}]}]},
  'CalcBoundingBox','Clear',
  {'CrossHair',1},
  'DestroyClippingRegion','DeviceToLogicalX','DeviceToLogicalXRel',
  'DeviceToLogicalY','DeviceToLogicalYRel',{'DrawArc',3},{'DrawBitmap',3},
  {'DrawCheckMark',1},{'DrawCircle',2},'DrawEllipse',{'DrawEllipticArc',4},
  {'DrawIcon',2},{'DrawLabel',4},{'DrawLine',2},
  {'DrawLines', [{"n",{c_only,{length,"points"}}}]},
  {'DrawPolygon', [{"n",{c_only,{length,"points"}}},
		   {"fillStyle", [{base, {enum, "wxPolygonFillMode"}}]}
		  ]},
  %%'DrawPolyPolygon',
  {'DrawPoint',1},'DrawRectangle',
  {'DrawRotatedText',3}, 'DrawRoundedRectangle',%'DrawSpline',
  {'DrawText',2},
  'EndDoc','EndPage',
  {{'FloodFill',3},[{"style", [{base, {enum, "wxFloodFillStyle"}}]}]},
  'GetBackground','GetBackgroundMode',
  'GetBrush','GetCharHeight','GetCharWidth',{'GetClippingBox',[{"rect", skip_member}]},
  'GetFont','GetLayoutDirection','GetLogicalFunction','GetMapMode','GetMultiLineTextExtent',
  {'GetPartialTextExtents', [{"widths", out}]},
  'GetPen',{'GetPixel', [{"colour", out}, {"x", skip_member}]},
  'GetPPI','GetSize','GetSizeMM',
  'GetTextBackground','GetTextExtent','GetTextForeground',
  'GetUserScale','GradientFillConcentric','GradientFillLinear',
  'LogicalToDeviceX','LogicalToDeviceXRel','LogicalToDeviceY','LogicalToDeviceYRel',
  'MaxX','MaxY','MinX','MinY','IsOk','ResetBoundingBox','SetAxisOrientation',
  'SetBackground','SetBackgroundMode','SetBrush','SetClippingRegion','SetDeviceOrigin',
  'SetFont','SetLayoutDirection',
  {'SetLogicalFunction', [{"function", [{base, {enum, "wxRasterOperationMode"}}]}]},
  {'SetMapMode', [{"mode", [{base, {enum, "wxMappingMode"}}]}]},
  'SetPalette',
  'SetPen','SetTextBackground','SetTextForeground','SetUserScale','StartDoc','StartPage']}.

{class,wxMirrorDC, wxDC, [], ['wxMirrorDC', '~wxMirrorDC']}.
{class,wxScreenDC, wxDC, [], ['wxScreenDC', '~wxScreenDC']}.
{class,wxPostScriptDC,wxDC,[{ifdef, wxUSE_POSTSCRIPT}],
 ['wxPostScriptDC','~wxPostScriptDC'
 ]}.
{class,wxWindowDC, wxDC, [], ['wxWindowDC', '~wxWindowDC']}.
{class,wxClientDC,wxWindowDC,[], ['wxClientDC', '~wxClientDC']}.
{class,wxPaintDC, wxWindowDC, [], ['wxPaintDC', '~wxPaintDC']}.
%%{class,wxPrinterDC, wxDC, [], ['wxPrinterDC','GetPaperRect']}. Not in GTK
{class,wxMemoryDC, wxDC, [], ['wxMemoryDC', '~wxMemoryDC','SelectObject','SelectObjectAsSource']}.
{class,wxBufferedDC,wxMemoryDC,[],['wxBufferedDC','~wxBufferedDC','Init']}.
{class,wxBufferedPaintDC,wxBufferedDC,[],['wxBufferedPaintDC', '~wxBufferedPaintDC']}.
%% Only a typedef!
%%{class,wxAutoBufferedPaintDC,wxBufferedPaintDC,[],['wxAutoBufferedPaintDC']}.

{class, wxGraphicsObject, object, [{ifdef, wxUSE_GRAPHICS_CONTEXT}],
 ['~wxGraphicsObject', 'GetRenderer','IsNull']}.
{class, wxGraphicsContext, wxGraphicsObject,
 [{ifdef, wxUSE_GRAPHICS_CONTEXT}, {skip, [{'StrokeLines',4}]}],
 ['~wxGraphicsContext',
  'Create', %%CreateFromNative CreateFromNativeWindow
  'CreatePen','CreateBrush',
  'CreateRadialGradientBrush',
  'CreateLinearGradientBrush',
  'CreateFont','CreateMatrix',
  'CreatePath','Clip','ResetClip',
  'DrawBitmap','DrawEllipse','DrawIcon',
  {'DrawLines', [{"n",{c_only,{length,"points"}}}, {"points", {single,array}},
		 {"fillStyle", [{base, {enum, "wxPolygonFillMode"}}]}]},
  {'DrawPath',[{"fillStyle", [{base, {enum, "wxPolygonFillMode"}}]}]},
  'DrawRectangle','DrawRoundedRectangle','DrawText',
  {'FillPath',[{"fillStyle", [{base, {enum, "wxPolygonFillMode"}}]}]},
  'StrokePath', %% 'GetNativeContext',
  {'GetPartialTextExtents', [{"widths", out}]},
  'GetTextExtent','Rotate','Scale','Translate',
  'GetTransform','SetTransform','ConcatTransform',
  'SetBrush','SetFont','SetPen','StrokeLine',
  {'StrokeLines', [{"n",{c_only,{length,"points"}}}, {"points", {single,array}}]}
 ]}.
{class, wxGraphicsMatrix, wxGraphicsObject, [{ifdef, wxUSE_GRAPHICS_CONTEXT}],
 ['Concat','Get',%%'GetNativeMatrix',
  'Invert','IsEqual','IsIdentity',
  'Rotate','Scale','Translate','Set','TransformPoint','TransformDistance']}.
{class, wxGraphicsPath, wxGraphicsObject, [{ifdef, wxUSE_GRAPHICS_CONTEXT}],
 ['MoveToPoint','AddArc','AddArcToPoint','AddCircle','AddCurveToPoint',
  'AddEllipse','AddLineToPoint','AddPath','AddQuadCurveToPoint',
  'AddRectangle','AddRoundedRectangle','CloseSubpath',
  {'Contains', [{"fillStyle", [{base, {enum, "wxPolygonFillMode"}}]}]},
  'GetBox','GetCurrentPoint','Transform'
  %'GetNativePath','UnGetNativePath'
 ]}.
{class, wxGraphicsRenderer, object, [{ifdef, wxUSE_GRAPHICS_CONTEXT}],
 ['GetDefaultRenderer','CreateContext',
  %%'CreateContextFromNativeContext', 'CreateContextFromNativeWindow',
  'CreateBrush',
  'CreateLinearGradientBrush', 'CreateRadialGradientBrush',
  'CreateFont',
  'CreateMatrix','CreatePath']}.

{class, wxGraphicsPen,  wxGraphicsObject,[{ifdef, wxUSE_GRAPHICS_CONTEXT}], []}.
{class, wxGraphicsBrush,wxGraphicsObject,[{ifdef, wxUSE_GRAPHICS_CONTEXT}], []}.
{class, wxGraphicsFont, wxGraphicsObject,[{ifdef, wxUSE_GRAPHICS_CONTEXT}], []}.
{class, wxGraphicsGradientStops, object, [{ifdef, wxUSE_GRAPHICS_CONTEXT}],
 [
  'wxGraphicsGradientStops', '~wxGraphicsGradientStops',
  'Item', 'GetCount',
  'SetStartColour', 'GetStartColour',
  'SetEndColour', 'GetEndColour',
  'Add'
 ]}.


{class, wxMenuBar, wxWindow, [{skip, [{wxMenuBar,4}]}],
 [
  'wxMenuBar','~wxMenuBar','Append','Check','Enable','EnableTop',
  'FindMenu', 'FindMenuItem',{'FindItem', [{"menu",skip}]},'GetHelpString',
  'GetLabel', {'GetMenuLabel', [{erl_alias, 'GetLabelTop'}]},
  'GetMenuLabelText',
  'GetMenu','GetMenuCount','Insert','IsChecked',
  {'SetAutoWindowMenu', [{test_if, "defined(__WXMAC__)"}]},
  {'GetAutoWindowMenu', [{test_if, "defined(__WXMAC__)"}]},
  {'OSXGetAppleMenu', [{test_if, "defined(__WXMAC__)"}]},
  {'MacGetCommonMenuBar', [{test_if, "defined(__WXMAC__)"}]},
  {'MacSetCommonMenuBar', [{test_if, "defined(__WXMAC__)"}]},
  'IsEnabled',%'Refresh',
  'Remove','Replace','SetHelpString',
  'SetLabel',
  {'SetMenuLabel', [{erl_alias, 'SetLabelTop'}]}
 ]}.

{class, wxControl, wxWindow, [], [% 'Command','GetLabelText',
				  'GetLabel','SetLabel']}.

{class, wxControlWithItems, wxControl,
 [{skip, [{'GetClientObject',1},{'SetClientObject',2}]}],
 [
  {'Append',[{"clientsData",[{single, array}]},
             {"items", [{erl_func, "appendStrings"}]}]},
  'Clear','Delete','FindString',
  %% 'GetClientData','SetClientData',
  {'GetClientObject', [{"n", [{erl_func, "getClientData"}]}]},
  {'SetClientObject', [{"n", [{erl_func, "setClientData"}]}]},
  'GetCount','GetSelection','GetString','GetStringSelection',
  {'Insert',[{"clientsData",[{single, array}]},
             {"items", [{erl_func, "insertStrings"}]}]},
  'IsEmpty','Select','SetSelection','SetString','SetStringSelection'
 ]}.

{enum, wxItemKind, "wxITEM_"}.

{class, wxMenu, wxEvtHandler, [],
 ['wxMenu','~wxMenu',{'Append', [{"text",{def,none}}]},
  'AppendCheckItem','AppendRadioItem',
  'AppendSeparator','Break','Check','Delete','Destroy','Enable',
  {'FindItem', [{"menu",skip}]},'FindItemByPosition','GetHelpString','GetLabel',
  'GetMenuItemCount','GetMenuItems','GetTitle','Insert',
  'InsertCheckItem','InsertRadioItem','InsertSeparator','IsChecked',
  'IsEnabled','Prepend','PrependCheckItem','PrependRadioItem',
  'PrependSeparator','Remove','SetHelpString','SetLabel','SetTitle']}.

{class, wxMenuItem, object, [],
 [{'wxMenuItem',[{"isCheckable",skip_member}]},
  '~wxMenuItem','Check','Enable',
  %%'GetBackgroundColour',
  'GetBitmap', %%'GetFont',
  'GetHelp','GetId','GetKind',{'GetLabelText', [{erl_alias, 'GetLabelFromText'}]},
  {'GetItemLabel', [{erl_alias, 'GetText'}]},
  {'GetItemLabelText',[{erl_alias, 'GetLabel'}]},
  %%'GetMarginWidth','GetTextColour',
  'GetMenu',%'GetName', class clash will not compile on windows
  'GetSubMenu','IsCheckable','IsChecked','IsEnabled',
  'IsSeparator','IsSubMenu',
  %%'SetBackgroundColour',
  'SetBitmap', %%'SetBitmaps',%%'SetFont',
  'SetHelp','SetMenu','SetSubMenu',
  {'SetItemLabel', [{erl_alias, 'SetText'}]}
  %%'SetTextColour',%'SetMarginWidth'
 ]}.

{class, wxToolBar, wxControl, [], 
 ['AddControl','AddSeparator','AddTool','AddCheckTool','AddRadioTool',
  'AddStretchableSpace',
  'InsertStretchableSpace',
  'DeleteTool','DeleteToolByPos','EnableTool','FindById','FindControl',
  'FindToolForPosition','GetToolSize','GetToolBitmapSize','GetMargins',
  %%'GetToolClientData' ,  %%'SetToolClientData',
  'GetToolEnabled','GetToolLongHelp','GetToolPacking',
  'GetToolPos','GetToolSeparation','GetToolShortHelp','GetToolState',
  'InsertControl','InsertSeparator','InsertTool',
  %%'OnLeftClick','OnMouseEnter','OnRightClick',
  'Realize','RemoveTool', %'SetBitmapResource',
  {'SetMargins',2},'SetToolBitmapSize', 
  'SetToolLongHelp',
  'SetToolPacking','SetToolShortHelp','SetToolSeparation','ToggleTool'
 ]}.

{class, wxStatusBar, wxWindow, [],
 [{'wxStatusBar',[{"size", skip_member}]},
  '~wxStatusBar',
  {'Create',[{"size", skip_member}]},
  {'GetFieldRect', [{"rect", out}]},
  'GetFieldsCount','GetStatusText','PopStatusText',
  'PushStatusText', 
  {'SetFieldsCount', [{"number", {def,none}},
		      {"widths", [{single, array}, {def, "(int *) NULL"}]}]},
  'SetMinHeight','SetStatusText',
  {'SetStatusWidths', [{"n",{c_only,{length,"widths_field"}}}]},
  {'SetStatusStyles', [{"n",{c_only,{length,"styles"}}}]}
 ]}.

{class, wxBitmap, object,[],
 [{'wxBitmap',[{"bits",[in,{base,binary}, {single,true}]},{{1,"bits"},skip_member}]},
  '~wxBitmap',%'AddHandler','CleanUpHandlers',
  'ConvertToImage',
  'CopyFromIcon','Create',%'FindHandler',
  'GetDepth','GetHeight',%'GetHandlers',
  'GetPalette',
  'GetMask','GetWidth','GetSubBitmap',
  %%'InitStandardHandlers','InsertHandler','RemoveHandler',
  'LoadFile',  {'IsOk', [{erl_alias, 'Ok'}]},
  'SaveFile','SetDepth',
  'SetHeight','SetMask','SetPalette',
  'SetWidth']}.

{class, wxIcon, wxBitmap,[],
 [%%{'wxIcon',[{"bits",[in,{base,binary}]}]},
  {'wxIcon',[{"bits",skip_member}]},  %% bits is char** in gtk and char[] in mac!!!
  'CopyFromBitmap','~wxIcon']}.

{class, wxIconBundle, root, [],
 [{'wxIconBundle', [{"module", skip_member}]},
  '~wxIconBundle',
  {'AddIcon', [{"module", skip_member}]},
 {'GetIcon', [{return, {by_val, true}}]}]}.

{class, wxCursor, wxBitmap,[], 
 ['wxCursor', '~wxCursor',  {'IsOk', [{erl_alias, 'Ok'}]}]}.

{class, wxMask, object, [], ['wxMask','~wxMask','Create']}.

{class, wxImage, object, [{doc,"All (default) image handlers are initialized."}],
 [{'wxImage',[{"xpmData",skip_member},
	      {"data",[in,{base,binary}, copy]},
	      {"alpha",[in,{base,binary}, copy]},
              {"static_data", nowhere}
	     ]},
  '~wxImage',%'AddHandler',
  'Blur','BlurHorizontal','BlurVertical', 
						%'CleanUpHandlers',%'ComputeHistogram',
  'ConvertAlphaToMask','ConvertToGreyscale',
  'ConvertToMono','Copy',
  {'Create',[{"xpmData",skip_member},
	     {"data",[in,{base,binary},copy]},
	     {"alpha",[in,{base,binary},copy]},
             {"static_data", nowhere}
	    ]},
  'Destroy','FindFirstUnusedColour', %  'FindHandler',
  'GetImageExtWildcard',
  {'GetAlpha',[{{0,return},{base,{binary,"(This->GetWidth()*This->GetHeight())"}}}]},
  'GetBlue',
  {'GetData', [{return,{base,{binary,"(This->GetWidth()*This->GetHeight()*3)"}}}]},
  'GetGreen',
  {'GetImageCount', [{"type", [{base, {enum, "wxBitmapType"}}]}]},
  %%'GetHandlers',
  'GetHeight','GetMaskBlue','GetMaskGreen',
  'GetMaskRed','GetOrFindMaskColour','GetPalette',
  'GetRed','GetSubImage', 'GetWidth',%%':HSVValue', 'HSVtoRGB',
  'HasAlpha','HasMask','GetOption','GetOptionInt','HasOption',
  'InitAlpha','InitStandardHandlers',%'InsertHandler',
  'IsTransparent', 'LoadFile', {'IsOk', [{erl_alias, 'Ok'}]}, %%RGBValue 'RGBtoHSV',
  'RemoveHandler','Mirror','Replace',
  {'Rescale', [{"quality", [{base, {enum, "wxImageResizeQuality"}}]}]},
  'Resize',
  'Rotate', 'RotateHue',
  'Rotate90','SaveFile',
  {'Scale', [{"quality", [{base, {enum, "wxImageResizeQuality"}}]}]},
  'Size',
  {'SetAlpha', [{{1,"alpha"}, [in,{base,binary},copy,{def,none}]}, {"static_data", nowhere}]},
  {'SetData',  [{"data",[in,{base,binary},copy]}, {"static_data", nowhere}]},
 'SetMask','SetMaskColour','SetMaskFromImage','SetOption',
  'SetPalette',
  'SetRGB']}.

{class, wxBrush, object, [],
 ['wxBrush','~wxBrush',
  {'GetColour', [{return, {by_val, true}}]},
  'GetStipple','GetStyle',
  'IsHatch','IsOk','SetColour','SetStipple','SetStyle']}.

{class, wxPen, object, [],
 ['wxPen','~wxPen','GetCap',
  {'GetColour', [{return, {by_val, true}}]},
  %%'GetDashes', %'GetStipple',
  'GetJoin', 'GetStyle','GetWidth','IsOk',
  {'SetCap', [{"capStyle", [{base, {enum, "wxPenCap"}}]}]},
  'SetColour',
  %%'SetDashes',  %'SetStipple',
  {'SetJoin', [{"joinStyle", [{base, {enum, "wxPenJoin"}}]}]}, 'SetStyle','SetWidth']}.

{enum, wxRegionContain, "wx"}.

{class, wxRegion, object, 
 [{skip, [{wxRegion,3}]}], % Hmm compiler can't handle that
 [{'wxRegion',[{"region", [skip_member]}]},
  '~wxRegion','Clear','Contains','ConvertToBitmap',
  {'GetBox',0},'Intersect','IsEmpty','Subtract','Offset',
  'Union','Xor']}.

{class, wxAcceleratorTable, object,
 [{skip, [{wxAcceleratorTable,1}]}],
 ['wxAcceleratorTable','~wxAcceleratorTable', {'IsOk', [{erl_alias, 'Ok'}]}]}.

{class, wxAcceleratorEntry, root, [], 
 ['wxAcceleratorEntry','GetCommand','GetFlags','GetKeyCode','Set']}.

{class, wxCaret, root,
 [{skip, [{wxCaret,0}]}],
 ['wxCaret','~wxCaret','Create','GetBlinkTime','GetPosition','GetSize','GetWindow','Hide','IsOk',
  'IsVisible','Move','SetBlinkTime','SetSize','Show']}.

{enum, wxFlexSizerGrowMode, "wxFLEX_GROWMODE_"}.

{class, wxSizer, object, [],
 [{'Add',[{"item", skip_member}]},
  'AddSpacer','AddStretchSpacer','CalcMin','Clear','Detach',
  'Fit', {'FitInside', [{erl_alias, 'SetVirtualSizeHints'}]},
  'GetChildren',%'GetContainingWindow',
  'GetItem','GetSize','GetPosition','GetMinSize',
  'Hide','Insert','InsertSpacer','InsertStretchSpacer','IsShown',
  {'Layout', [{erl_alias, 'RecalcSizes'}]},
  'Prepend', 'PrependSpacer','PrependStretchSpacer',
  %%'RecalcSizes',  Not available in 3.0 implementation helper only
  {'Remove', [{"window", skip_member}]}, 'Replace',
  'SetDimension','SetMinSize','SetItemMinSize','SetSizeHints',
  %% 'SetVirtualSizeHints',
  'Show', 'ShowItems']}.

{class, wxSizerFlags, root, [],
 ['wxSizerFlags','Align','Border',{'Center',[{erl_alias, 'Centre'}]},
  %%'DoubleBorder','DoubleHorzBorder',
  'Expand',%'GetDefaultBorder',
  'Left','Proportion','Right'%,'TripleBorder'
 ]}.

{class, wxSizerItem, object, [], 
 ['wxSizerItem','~wxSizerItem','CalcMin','DeleteWindows','DetachSizer','GetBorder',
  'GetFlag','GetMinSize','GetPosition','GetProportion','GetRatio','GetRect','GetSize',
  'GetSizer','GetSpacer','GetUserData','GetWindow','IsSizer','IsShown','IsSpacer',
  'IsWindow','SetBorder','SetDimension','SetFlag','SetInitSize','SetMinSize',
  'SetProportion','SetRatio','AssignSizer','AssignSpacer','AssignWindow','Show']}.

{class,wxBoxSizer,wxSizer,[],['wxBoxSizer','GetOrientation']}.
{class,wxStaticBoxSizer,wxBoxSizer,[],['wxStaticBoxSizer','GetStaticBox']}.

{class,wxGridSizer,wxSizer,[],
 ['wxGridSizer','GetCols','GetHGap','GetRows','GetVGap','SetCols','SetHGap',
  'SetRows','SetVGap']}.

{class,wxFlexGridSizer,wxGridSizer,[],
 ['wxFlexGridSizer','AddGrowableCol','AddGrowableRow','GetFlexibleDirection',  
  'GetNonFlexibleGrowMode','RemoveGrowableCol','RemoveGrowableRow',
  'SetFlexibleDirection','SetNonFlexibleGrowMode']}.

{class,wxGridBagSizer,wxFlexGridSizer,[],
 ['wxGridBagSizer','Add','CalcMin','CheckForIntersection','FindItem',
  'FindItemAtPoint','FindItemAtPosition','FindItemWithData','GetCellSize',
  'GetEmptyCellSize','GetItemPosition','GetItemSpan',
  'SetEmptyCellSize','SetItemPosition','SetItemSpan']}.

{class,wxGBSizerItem,wxSizerItem,[],[]}.
%%  [{skip, [{'GetEndPos',3},{'GetPos',3},{'GetSpan',3}]}],
%%  ['wxGBSizerItem','GetEndPos','GetPos','GetSpan','Intersects','SetPos','SetSpan']}.

{class,wxStdDialogButtonSizer,wxBoxSizer,[],
 ['wxStdDialogButtonSizer','~wxStdDialogButtonSizer','AddButton','Realize',
  'SetAffirmativeButton','SetCancelButton','SetNegativeButton']}.

{enum, wxFontFamily, "wxFONTFAMILY_"}.
{enum, wxFontStyle,  "wxFONTSTYLE_"}.
{enum, wxFontEncoding,"wxFONTENCODING_"}.

{class, wxFont, object, [],
 [{'wxFont',[{"info", [skip_member]},{"family",{base,{enum,"wxFontFamily"}}},
	     {"style",{base,{enum,"wxFontStyle"}}}]},
  '~wxFont','IsFixedWidth','GetDefaultEncoding','GetFaceName',
  {'GetFamily',[{return, {base,{enum,"wxFontFamily"}}}]},
  'GetNativeFontInfoDesc','GetNativeFontInfoUserDesc','GetPointSize',
  {'GetStyle',[{return, {base,{enum,"wxFontStyle"}}}]},
  'GetUnderlined','GetWeight',%% {'New',[{"nativeFontDesc", [skip_member]}]},
  {'IsOk', [{erl_alias, 'Ok'}]},
  'SetDefaultEncoding','SetFaceName',
  {'SetFamily',[{"family", {base,{enum,"wxFontFamily"}}}]},
  %%'SetNativeFontInfo','SetNativeFontInfoUserDesc',
  'SetPointSize',
  {'SetStyle', [{"style", {base,{enum,"wxFontStyle"}}}]},
  'SetUnderlined','SetWeight']}.

{class, wxToolTip, object, [],
 ['Enable','SetDelay','wxToolTip','SetTip','GetTip','GetWindow']}.
{class, wxButton, wxControl, [],
 ['wxButton','~wxButton','Create',%'GetLabel',
  {'GetDefaultSize', [{{func,1}, [{test_if, "wxCHECK_VERSION(3,1,3)"}]}]},
  'SetDefault','SetLabel',
  {'GetBitmapDisabled', [{return, {by_val, true}}]},
  {'GetBitmapFocus', [{return, {by_val, true}}]},
  {'GetBitmapLabel', [{return, {by_val, true}}]},
  'SetBitmapDisabled','SetBitmapFocus','SetBitmapLabel'
 ]}.
{class, wxBitmapButton, wxButton, [], 
 ['wxBitmapButton','~wxBitmapButton','Create', 'NewCloseButton']}.
{class, wxToggleButton, wxControl, [], 
 ['wxToggleButton','~wxToggleButton','Create','GetValue','SetValue']}.

%%{enum, {"wxDateTime", "WeekDay"}, "wxDateTime::WeekDay"}.
{class, wxDateTime, root, [ignore], []}.  %% Only for ifdefs and enums

{class, wxCalendarCtrl, wxControl, [], 
 ['wxCalendarCtrl','Create','~wxCalendarCtrl','SetDate',
  {'GetDate', [{return, {by_val, true}}]},
  {'EnableYearChange', [{deprecated, "!wxCHECK_VERSION(2,9,0)"}]}, %% Temp bug in wx I assume
  'EnableMonthChange','EnableHolidayDisplay',
  'SetHeaderColours','GetHeaderColourFg','GetHeaderColourBg',
  'SetHighlightColours','GetHighlightColourFg','GetHighlightColourBg',
  'SetHolidayColours','GetHolidayColourFg','GetHolidayColourBg',
  'GetAttr','SetAttr','SetHoliday','ResetAttr',
  {'HitTest', [{"date", [out]}, {"wd", [out]}]}
 ]}.

{class, wxCalendarDateAttr, root, [], 
 ['wxCalendarDateAttr',
  'SetTextColour','SetBackgroundColour','SetBorderColour',
  'SetFont','SetBorder','SetHoliday',
  'HasTextColour','HasBackgroundColour','HasBorderColour',
  'HasFont','HasBorder','IsHoliday','GetTextColour',
  'GetBackgroundColour','GetBorderColour','GetFont','GetBorder']}.

{enum, wxCheckBoxState, "wxCHK_"}.

{class, wxCheckBox, wxControl, [], 
 ['wxCheckBox','~wxCheckBox','Create','GetValue','Get3StateValue',
  'Is3rdStateAllowedForUser','Is3State','IsChecked','SetValue',
  'Set3StateValue']}.
{class, wxCheckListBox, wxListBox, [{skip,[{wxCheckListBox,8}]}],
 [{'wxCheckListBox',[{"pos",{def, "wxDefaultPosition"}}, 
		     {"size",{def, "wxDefaultSize"}}, 
		     {"choices",{def, ""}}]},   
  '~wxCheckListBox','Check','IsChecked']}.
{class, wxChoice, wxControlWithItems, [{skip,[{wxChoice,8}, {'Create',9}]}], 
 [{'wxChoice', [{"pos",{def, "wxDefaultPosition"}}, 
		{"size",{def, "wxDefaultSize"}}, 
		{"choices",{def, ""}}]},
  '~wxChoice','Create','Delete','GetColumns',
  %%'GetCurrentSelection',
  'SetColumns']}.
{class, wxComboBox, wxControlWithItems, [{skip,[{wxComboBox,9},{'Create',10}]}], 
 [{'wxComboBox',
   [{"pos",{def, "wxDefaultPosition"}}, 
    {"size",{def, "wxDefaultSize"}}, 
    {"value", {def, "wxEmptyString"}},
    {"choices",{def, ""}}]},
  '~wxComboBox','Create','CanCopy','CanCut','CanPaste',
  'CanRedo','CanUndo','Copy','Cut','GetInsertionPoint','GetLastPosition',
  'GetValue','Paste','Redo','Replace','Remove','SetInsertionPoint',
  'SetInsertionPointEnd','SetSelection','SetValue','Undo']}.
{class, wxGauge, wxControl, [],
 ['wxGauge','~wxGauge','Create','GetRange',
  'GetValue','IsVertical','SetRange','SetValue',
  'Pulse']}.
{class, wxGenericDirCtrl, wxControl, [], 
 ['wxGenericDirCtrl','~wxGenericDirCtrl','Create','Init','CollapseTree',
  'ExpandPath','GetDefaultPath','GetPath','GetFilePath', 'GetFilter',
  'GetFilterIndex',%'GetFilterListCtrl',
  'GetRootId','GetTreeCtrl',
  'ReCreateTree','SetDefaultPath','SetFilter','SetFilterIndex','SetPath']}.
%% {class, wxHtmlListBox, wxControl, [], []}.
{class, wxStaticBox, wxControl, [], ['wxStaticBox','~wxStaticBox','Create']}.
{class, wxStaticLine, wxControl, [], ['wxStaticLine','~wxStaticLine','Create',
				      'IsVertical', 'GetDefaultSize']}.

{enum, wxListColumnFormat, "wxLIST_"}.

{class, wxListBox, wxControlWithItems, 
 [{skip,[{wxListBox,8}, {'Create',9}, {'Set',4}]}], 
 [{'wxListBox',[{"pos",{def, "wxDefaultPosition"}}, 
		{"size",{def, "wxDefaultSize"}}, 
		{"choices",{def, ""}}]},
  '~wxListBox','Create','Deselect',{'GetSelections',[{"selections", [out]}]},
  {'InsertItems',2},'IsSelected',{'Set',[{"clientData",[nowhere]}, {"n", skip_member}]},
  'HitTest',
  'SetFirstItem']}.

{class, wxListCtrl, wxControl, [],
 [{'wxListCtrl', [{"id", {def, "wxID_ANY"}}, {where, taylormade}]},
  '~wxListCtrl','Arrange','AssignImageList','ClearAll',
  {'Create',[{"id", {def, "wxID_ANY"}}, {where, taylormade}]},
  'DeleteAllItems','DeleteColumn','DeleteItem',
  {'EditLabel',[{"textControlClass",nowhere}]},
  'EnsureVisible',
  {'FindItem',3},'GetColumn','GetColumnCount','GetColumnWidth','GetCountPerPage',
  'GetEditControl',
  'GetImageList','GetItem','GetItemBackgroundColour',
  'GetItemCount',{'GetItemData', [{return, {base,int}}]},
  'GetItemFont', {'GetItemPosition', [{"pos", out}]},{'GetItemRect',[{"rect", out}]},
  'GetItemSpacing','GetItemState',
  'GetItemText','GetItemTextColour',
  'GetNextItem','GetSelectedItemCount','GetTextColour','GetTopItem',
  'GetViewRect',{'HitTest',[{"pSubItem",out}]},
  'InsertColumn','InsertItem',
  %%'OnGetItemAttr', 'OnGetItemImage','OnGetItemText',
  'RefreshItem','RefreshItems','ScrollList',
  'SetBackgroundColour','SetColumn','SetColumnWidth','SetImageList','SetItem',
  'SetItemBackgroundColour','SetItemCount','SetItemData','SetItemFont',
  'SetItemImage','SetItemColumnImage','SetItemPosition','SetItemState',
  'SetItemText','SetItemTextColour','SetSingleStyle','SetTextColour',
   'SetWindowStyleFlag',
   {'SortItems', [{where, taylormade}]}
 ]}.
{class, wxListView, wxControl, [],
 ['ClearColumnImage','Focus','GetFirstSelected','GetFocusedItem',
  'GetNextSelected','IsSelected','Select','SetColumnImage']}.

{class, wxListItem, object, [],
 ['wxListItem','~wxListItem','Clear','GetAlign','GetBackgroundColour','GetColumn', %'GetData',
  'GetFont','GetId','GetImage','GetMask','GetState',
  'GetText','GetTextColour','GetWidth','SetAlign','SetBackgroundColour',
  'SetColumn',%'SetData',
  'SetFont','SetId','SetImage','SetMask','SetState',
  'SetStateMask','SetText','SetTextColour','SetWidth']}.

{class, wxListItemAttr, root, [],
 ['wxListItemAttr','~wxListItemAttr',
  'GetBackgroundColour', 'GetFont',
  'GetTextColour', 'HasBackgroundColour', 'HasFont',
  'HasTextColour', 'SetBackgroundColour', 'SetFont', 'SetTextColour'
 ]}.

{class, wxImageList, object, [{skip, [{'Create',1}, {'GetSize', 1}]}], %% No create/0 on windows
 ['wxImageList','~wxImageList','Add','Create','Draw','GetBitmap','GetIcon','GetImageCount',
  'GetSize', 'Remove','RemoveAll','Replace']}.

{enum, wxTextAttrAlignment, "wxTEXT_ALIGNMENT_"}.

{class, wxTextAttr, root, [],
 ['wxTextAttr','GetAlignment','GetBackgroundColour',
  {'GetFont', [{return, {by_val, true}}]},
  'GetFontEncoding','GetFontFaceName','GetFontSize','GetFontStyle','GetFontUnderlined','GetFontWeight',
  'GetLeftIndent','GetLeftSubIndent','GetRightIndent','GetTabs','GetTextColour',
  'HasBackgroundColour','HasFont','HasTextColour','GetFlags','IsDefault',
  'SetAlignment','SetBackgroundColour','SetFlags','SetFont',
  'SetFontEncoding','SetFontFaceName','SetFontFamily','SetFontSize','SetFontPointSize','SetFontPixelSize',
  'SetFontStyle',{'SetFontUnderlined',1},'SetFontWeight',
  'SetLeftIndent',
  'SetRightIndent','SetTabs','SetTextColour']}.

{class, wxTextCtrl, wxControl, [],
 ['wxTextCtrl','~wxTextCtrl','AppendText','CanCopy','CanCut','CanPaste',
  'CanRedo','CanUndo','Clear','Copy','Create','Cut','DiscardEdits',
  'ChangeValue',
  'EmulateKeyPress','GetDefaultStyle','GetInsertionPoint','GetLastPosition',
  'GetLineLength','GetLineText','GetNumberOfLines','GetRange','GetSelection',
  'GetStringSelection','GetStyle','GetValue',%'HitTest', %no Mac
  'IsEditable',
  'IsModified','IsMultiLine','IsSingleLine','LoadFile','MarkDirty',
  %%'OnDropFiles',
  'Paste','PositionToXY','Redo','Remove','Replace',
  'SaveFile','SetDefaultStyle','SetEditable','SetInsertionPoint',
  'SetInsertionPointEnd','SetMaxLength','SetSelection','SetStyle',
  'SetValue','ShowPosition','Undo','WriteText','XYToPosition']}.

{class, wxBookCtrlBase, wxControl, [],
 [
  'AddPage', 'InsertPage',
  'DeletePage',  'RemovePage', 'DeleteAllPages',
  'GetPage', 'GetPageCount', 'GetCurrentPage',
  'AdvanceSelection', 'SetSelection', 'GetSelection', 'ChangeSelection',
  'HitTest','GetPageText','SetPageText'
 ]}.


{class,wxNotebook, wxBookCtrlBase, [],
 ['wxNotebook','~wxNotebook', %% 'AddPage',
  'AssignImageList','Create',
  'GetImageList',
  'GetPageImage','GetRowCount',
  'GetThemeBackgroundColour',
  %%'OnSelChange', callback
  'SetImageList','SetPadding','SetPageSize',
  'SetPageImage']}.

{class,wxChoicebook, wxBookCtrlBase, [], 
 ['wxChoicebook','~wxChoicebook','AddPage','AdvanceSelection',
  'AssignImageList','Create','DeleteAllPages',
  'GetCurrentPage','GetImageList','GetPage','GetPageCount',
  'GetPageImage','GetPageText',
  %% NOTEBOOK ONLY? 'GetRowCount', 'GetThemeBackgroundColour','SetPadding'
  'GetSelection',
  'HitTest', 
  'InsertPage',
  %%'OnSelChange', callback
  'SetImageList','SetPageSize',
  'SetPageImage','SetPageText','SetSelection','ChangeSelection']}.

{class,wxToolbook, wxBookCtrlBase, [], 
 ['wxToolbook','~wxToolbook','AddPage','AdvanceSelection',
  'AssignImageList','Create','DeleteAllPages',
  'GetCurrentPage','GetImageList','GetPage','GetPageCount',
  'GetPageImage','GetPageText',
  %% NOTEBOOK ONLY? 'GetRowCount', 'GetThemeBackgroundColour','SetPadding'
  'GetSelection',
  'HitTest', 
  'InsertPage',
  %%'OnSelChange', callback
  'SetImageList','SetPageSize',
  'SetPageImage','SetPageText','SetSelection','ChangeSelection']}.

{class,wxListbook, wxBookCtrlBase, [], 
 ['wxListbook','~wxListbook','AddPage','AdvanceSelection',
  'AssignImageList','Create','DeleteAllPages',
  'GetCurrentPage','GetImageList','GetPage','GetPageCount',
  'GetPageImage','GetPageText',
  %% NOTEBOOK ONLY? 'GetRowCount', 'GetThemeBackgroundColour','SetPadding'
  'GetSelection',
  'HitTest', 
  'InsertPage',
  %%'OnSelChange', callback
  'SetImageList','SetPageSize',
  'SetPageImage','SetPageText','SetSelection','ChangeSelection']}.

{class,wxTreebook, wxBookCtrlBase, [], 
 ['wxTreebook','~wxTreebook','AddPage','AdvanceSelection',
  'AssignImageList','Create','DeleteAllPages',
  'GetCurrentPage','GetImageList','GetPage','GetPageCount',
  'GetPageImage','GetPageText',
  %% NOTEBOOK ONLY? 'GetRowCount', 'GetThemeBackgroundColour','SetPadding'
  'GetSelection',
  'ExpandNode', 'IsNodeExpanded', 
  'HitTest', 
  'InsertPage','InsertSubPage',
  %%'OnSelChange', callback
  'SetImageList','SetPageSize',
  'SetPageImage','SetPageText','SetSelection','ChangeSelection']}.


{enum, wxTreeItemIcon, "wxTreeItemIcon_"}.

{class, wxTreeCtrl, wxControl,
 [{doc,
   "Note: The representation of treeItemId() have changed "
   "from the original class implementation to be an semi-opaque type,"
   "Equality between TreeItemId's can be tested and zero means that the TreeItem is invalid."
  }],
 ['wxTreeCtrl','~wxTreeCtrl','AddRoot','AppendItem',
  %% Not on Windows 'AssignButtonsImageList','GetButtonsImageList','SetButtonsImageList' 
  'AssignImageList','AssignStateImageList','Collapse','CollapseAndReset',
  'Create','Delete','DeleteAllItems','DeleteChildren',
  {'EditLabel', [{"textCtrlClass", [nowhere]}]}, %'EndEditLabel',
  'EnsureVisible','Expand',{'GetBoundingRect', [{"rect", [out]}]},
  'GetChildrenCount','GetCount','GetEditControl',
  {'GetFirstChild',[{"cookie", out}]}, {'GetNextChild',[{"cookie", [both]}]},
  'GetFirstVisibleItem',{'GetImageList',0},'GetIndent',
  'GetItemBackgroundColour','GetItemData','GetItemFont','GetItemImage',
  'GetItemText','GetItemTextColour','GetLastChild',
  'GetNextSibling','GetNextVisible','GetItemParent',%'GetParent',
  'GetPrevSibling','GetPrevVisible','GetRootItem',
  'GetSelection',{'GetSelections', [{"selection",out}]},
  'GetStateImageList', {{'HitTest', 2}, [{"flags", out}]},
  {'InsertItem',[{"insertAfter", skip_member}]},
  'IsBold','IsExpanded','IsSelected','IsVisible','ItemHasChildren',
  {'IsTreeItemIdOk', [{where, taylormade}]},
  %%'OnCompareItems',
  'PrependItem','ScrollTo','SelectItem',
  'SetIndent',{'SetImageList',1},'SetItemBackgroundColour',
  'SetItemBold','SetItemData','SetItemDropHighlight','SetItemFont',
  'SetItemHasChildren','SetItemImage','SetItemText',
  'SetItemTextColour','SetStateImageList','SetWindowStyle',{'SortChildren',1},
  'Toggle','ToggleItemSelection','Unselect','UnselectAll','UnselectItem']}.

{class, wxScrollBar, wxControl, [],
 ['wxScrollBar','~wxScrollBar','Create','GetRange','GetPageSize',
  'GetThumbPosition','GetThumbSize','SetThumbPosition','SetScrollbar']}.
{class, wxSpinButton, wxControl, [],
 ['wxSpinButton','~wxSpinButton','Create','GetMax','GetMin','GetValue','SetRange','SetValue']}.
{class, wxSpinCtrl, wxControl, [], 
 ['wxSpinCtrl','Create','SetValue','GetValue','SetRange','SetSelection','GetMin','GetMax']}.

{class, wxStaticText, wxControl, [], 
 ['wxStaticText','Create','GetLabel','SetLabel','Wrap']}.
{class, wxStaticBitmap, wxControl, [], 
 ['wxStaticBitmap','Create','GetBitmap','SetBitmap'
  %%wxStaticIcon::GetIcon wxStaticIcon::SetIcon
 ]}.
{class, wxRadioBox, wxControl, [], 
 [{'wxRadioBox',9},'~wxRadioBox',{'Create',9},'Enable',
  'GetSelection','GetString', 'SetSelection','Show',
  'GetColumnCount','GetItemHelpText','GetItemToolTip','GetItemFromPoint',
  'GetRowCount', 'IsItemEnabled','IsItemShown','SetItemHelpText','SetItemToolTip'
 ]}.
{class, wxRadioButton, wxControl, [], 
 ['wxRadioButton','~wxRadioButton','Create','GetValue','SetValue']}.

{class, wxSlider, wxControl, [], 
 ['wxSlider','~wxSlider', %'ClearSel','ClearTicks',
  'Create','GetLineSize','GetMax','GetMin',
  'GetPageSize',%'GetSelEnd','GetSelStart',
  'GetThumbLength',%'GetTickFreq',
  'GetValue',
  'SetLineSize','SetPageSize','SetRange',%'SetSelection',
  'SetThumbLength',%'SetTick',  'SetTickFreq',
  'SetValue']}.

{class, wxDialog, wxTopLevelWindow, [], 
 ['wxDialog','~wxDialog',%'Centre',
  'Create','CreateButtonSizer',
  'CreateStdDialogButtonSizer',%'DoOK',
  'EndModal','GetAffirmativeId',
  'GetReturnCode', %'GetTitle','GetToolBar','Iconize','IsIconized',
  'IsModal',
  %%'OnApply','OnCancel','OnOK', 'OnSysColourChanged',
  'SetAffirmativeId', %'SetIcon','SetIcons','SetTitle',
  %% 'SetModal', Deprecated
  'SetReturnCode','Show','ShowModal']}.

{class, wxColourDialog, wxDialog, [], 
 ['wxColourDialog','~wxColourDialog','Create','GetColourData']}.

{class, wxColourData, object, [], 
 ['wxColourData','~wxColourData','GetChooseFull','GetColour','GetCustomColour',
  'SetChooseFull','SetColour','SetCustomColour']}.

{class, wxPalette, object, [], 
 [{'wxPalette',[{"n", {c_only,{size,"red"}}},
                {"red",[in,{base,binary}]},
		{"green", [in,{base,binary}]},
                {"blue", [in,{base,binary}]}]},
  '~wxPalette',
  {'Create', [{"n", {c_only,{size,"red"}}},
              {"red",[in,{base,binary}]},
	      {"green", [in,{base,binary}]},
              {"blue", [in,{base,binary}]}]},
  'GetColoursCount','GetPixel',
  'GetRGB',
  {'IsOk', [{erl_alias, 'Ok'}]}]}.

{class, wxDirDialog, wxDialog, 
 [{alias, [{wxGenericDirDialog,wxDirDialog}]}, {skip, [{wxDirDialog,0}]}], 
 ['wxDirDialog','~wxDirDialog','GetPath','GetMessage','SetMessage',
  'SetPath']}.

{class, wxFileDialog, wxDialog, [{skip, [{wxFileDialog,0}]}], 
 ['wxFileDialog','~wxFileDialog','GetDirectory','GetFilename',
  {'GetFilenames',[{"filenames", out}]},
  'GetFilterIndex','GetMessage','GetPath',
  {'GetPaths', [{"paths", out}]},
  'GetWildcard',
  'SetDirectory','SetFilename','SetFilterIndex','SetMessage','SetPath',
  'SetWildcard']}.

%% {class, wxGenericFileDialog, wxDialog, [], 
%%  ['wxFileDialog','~wxFileDialog','GetDirectory','GetFilename','GetFilenames',
%%   'GetFilterIndex','GetMessage','GetPath','GetPaths','GetStyle','GetWildcard',
%%   'SetDirectory','SetFilename','SetFilterIndex','SetMessage','SetPath','SetStyle',
%%   'SetWildcard']}.

{class, wxPickerBase, wxControl, [], 
 ['SetInternalMargin','GetInternalMargin','SetTextCtrlProportion',
  'SetPickerCtrlProportion','GetTextCtrlProportion','GetPickerCtrlProportion',
  'HasTextCtrl','GetTextCtrl','IsTextCtrlGrowable','SetPickerCtrlGrowable',
  'SetTextCtrlGrowable','IsPickerCtrlGrowable']}.

{class, wxFilePickerCtrl, wxPickerBase, [], 
 ['wxFilePickerCtrl','Create','GetPath','SetPath']}.

{class, wxDirPickerCtrl, wxPickerBase, [], 
 ['wxDirPickerCtrl','Create','GetPath','SetPath']}.

{class, wxColourPickerCtrl, wxPickerBase, [],
 ['wxColourPickerCtrl','Create','GetColour','SetColour']}.

{class, wxDatePickerCtrl, wxPickerBase, [],
 ['wxDatePickerCtrl',  %'Create',  
  'GetRange',  'GetValue', %'SetFormat', Not always available 
  'SetRange',  'SetValue']}.

{class, wxFontPickerCtrl, wxPickerBase,  [],
 ['wxFontPickerCtrl','Create','GetSelectedFont','SetSelectedFont',
  'GetMaxPointSize','SetMaxPointSize']}.

{class, wxFindReplaceDialog, wxDialog, 
 [{alias, [{wxGenericFindReplaceDialog,wxFindReplaceDialog}]}], 
 ['wxFindReplaceDialog','~wxFindReplaceDialog','Create','GetData']}.

{class, wxFindReplaceData, object, [], 
 ['wxFindReplaceData','~wxFindReplaceData','GetFindString','GetReplaceString',
  'GetFlags','SetFlags','SetFindString','SetReplaceString']}.

{class, wxMultiChoiceDialog, wxDialog, [{skip, [{wxMultiChoiceDialog, 7}]}], 
 ['wxMultiChoiceDialog','GetSelections','SetSelections']}.
{class, wxSingleChoiceDialog, wxDialog, [{skip, [{wxSingleChoiceDialog, 8}]}], 
 [{'wxSingleChoiceDialog', [{"clientData", [skip,in]}]},
  'GetSelection', %% 'GetSelectionClientData', obsolete
  'GetStringSelection','SetSelection']}.

{class, wxTextEntryDialog, wxDialog, [], 
 ['wxTextEntryDialog','~wxTextEntryDialog','GetValue','SetValue']}.

{class, wxPasswordEntryDialog, wxTextEntryDialog, [], ['wxPasswordEntryDialog']}.

{class, wxFontData, object, [], 
 ['wxFontData','~wxFontData',
  'EnableEffects','GetAllowSymbols','GetColour','GetChosenFont',
  'GetEnableEffects','GetInitialFont','GetShowHelp','SetAllowSymbols',
  'SetChosenFont','SetColour','SetInitialFont','SetRange','SetShowHelp']}.

{class, wxFontDialog, wxDialog, 
 [{skip, [{'wxFontDialog',1}, {'Create',2}]}],  %% Not available on Mac!!
 ['wxFontDialog','Create','GetFontData']}.

{class, wxProgressDialog, wxDialog, [], 
 ['wxProgressDialog','~wxProgressDialog','Resume',{'Update', [{"skip", nowhere}]}]}.
{class, wxMessageDialog, wxDialog, [], 
 ['wxMessageDialog', '~wxMessageDialog']}.

{enum, wxPrintBin, "wxPRINTBIN_"}.
{enum, wxDuplexMode, "wxDUPLEX_"}.
{enum, wxPrintMode, "wxPRINT_MODE_"}.
%%{enum, wxPaperSize,"wxPAPER_"}.

{class, wxPageSetupDialog, object, [], 
 ['wxPageSetupDialog','~wxPageSetupDialog','GetPageSetupData', 'ShowModal']}.

{class, wxPageSetupDialogData, object, [], 
 ['wxPageSetupDialogData','~wxPageSetupDialogData','EnableHelp','EnableMargins',
  'EnableOrientation','EnablePaper','EnablePrinter','GetDefaultMinMargins',
  'GetEnableMargins','GetEnableOrientation','GetEnablePaper','GetEnablePrinter',
  'GetEnableHelp','GetDefaultInfo','GetMarginTopLeft','GetMarginBottomRight',
  'GetMinMarginTopLeft','GetMinMarginBottomRight','GetPaperId','GetPaperSize',
  'GetPrintData','IsOk','SetDefaultInfo','SetDefaultMinMargins','SetMarginTopLeft',
  'SetMarginBottomRight','SetMinMarginTopLeft','SetMinMarginBottomRight',
  'SetPaperId','SetPaperSize','SetPrintData']}.
{class, wxPrintDialog, wxDialog, [], 
 ['wxPrintDialog','~wxPrintDialog','GetPrintDialogData','GetPrintDC']}.
{class,wxPrintDialogData, object, [], 
 ['wxPrintDialogData','~wxPrintDialogData','EnableHelp','EnablePageNumbers',
  'EnablePrintToFile','EnableSelection','GetAllPages','GetCollate','GetFromPage',
  'GetMaxPage','GetMinPage','GetNoCopies','GetPrintData','GetPrintToFile',
  'GetSelection','GetToPage','IsOk','SetCollate','SetFromPage','SetMaxPage',
  'SetMinPage','SetNoCopies','SetPrintData','SetPrintToFile','SetSelection',
  %%'SetSetupDialog', not found
  'SetToPage']}.

{class, wxPrintData, object, [],
 ['wxPrintData','~wxPrintData','GetCollate','GetBin','GetColour',
  'GetDuplex','GetNoCopies','GetOrientation','GetPaperId','GetPrinterName',
  'GetQuality','IsOk','SetBin','SetCollate','SetColour','SetDuplex','SetNoCopies',
  'SetOrientation','SetPaperId','SetPrinterName','SetQuality']}.

{class, wxPrintPreview, object, [], 
 ['wxPrintPreview','~wxPrintPreview','GetCanvas','GetCurrentPage',
  'GetFrame','GetMaxPage','GetMinPage','GetPrintout','GetPrintoutForPrinting',
  'IsOk','PaintPage','Print','RenderPage','SetCanvas','SetCurrentPage',
  'SetFrame','SetPrintout','SetZoom']}.

{class, wxPreviewFrame, wxFrame, [],
 ['wxPreviewFrame','~wxPreviewFrame','CreateControlBar','CreateCanvas',
  'Initialize','OnCloseWindow']}.

{class, wxPreviewControlBar, wxPanel, [],
['wxPreviewControlBar','~wxPreviewControlBar','CreateButtons','GetPrintPreview',
 'GetZoomControl','SetZoomControl']}.

{class, wxPreviewCanvas, wxScrolledWindow, [], []}.

{class, wxPrinter, object, [],
 ['wxPrinter',  {'CreateAbortWindow', [{return, [{base, {class, "wxDialog"}}]}]},
  'GetAbort','GetLastError',
  'GetPrintDialogData','Print','PrintDialog','ReportError','Setup']}.
  
{class, wxXmlResource, object, [], 
 ['wxXmlResource', '~wxXmlResource', 
  %%'AddHandler', removed wxXmlResourceHandler is not implemented yet
  'AttachUnknownControl', 
  'ClearHandlers', 'CompareVersion', 
  'Get', 'GetFlags', 'GetVersion', 
  'GetXRCID',
  'InitAllHandlers', 'Load', 
  'LoadBitmap', 'LoadDialog', 'LoadFrame', 'LoadIcon', 'LoadMenu', 'LoadMenuBar', 'LoadPanel', 
  'LoadToolBar', 'Set', 'SetFlags', 'Unload',
  {xrcctrl,[{where, taylormade}]}
  %,{'GetDomain', [{return, [{single, array}]}]}, 'SetDomain'
  ]}.

{class, wxHtmlEasyPrinting, object, [],
 ['wxHtmlEasyPrinting','~wxHtmlEasyPrinting',
  %'GetParentWindow',  Not found
  'GetPrintData','GetPageSetupData','PreviewFile',
  'PreviewText','PrintFile','PrintText','PageSetup',
  {'SetFonts',[{"sizes", [{single, array}, {def, "(int *) NULL"}]}]},
  'SetHeader','SetFooter'%,'SetParentWindow'
 ]}.

%%{class, wxVListBox, wxControl, [], []}.

{class, wxGLCanvas, wxWindow,
 [{ifdef, wxUSE_GLCANVAS}], %% NA MAC
 [{'wxGLCanvas', [{"attribList", [in, {single,array}]},
                  {pre_hook, [{erl, "{ok, _} = wxe_master:init_opengl(),"}]}
                 ]},
  {'SetCurrent', [{post_hook,[{c, "setActiveGL(memenv, Ecmd.caller, This, context)"}]}]},
  {'CreateSurface', [{test_if, "wxUSE_GLCANVAS_EGL"},
                     {pre_hook,
                      [{c,  %% Workaround for EGL and 3.2.* crashes
                        "\n#if !wxCHECK_VERSION(3,2,3)\n"
                        "  if(!This) throw wxe_badarg(0);\n"
                        "  if(This->GetEGLSurface() != EGL_NO_SURFACE)\n"
                        "     eglDestroySurface(This->GetEGLDisplay(), This->GetEGLSurface());\n"
                        "#endif\n"
                       }]}
                    ]},
  'IsDisplaySupported',
  'SwapBuffers']}.

{class, wxGLContext, object, [{ifdef, wxUSE_GLCANVAS}],
 [{'wxGLContext', [{"ctxAttrs", nowhere}]},
  {'SetCurrent', [{post_hook,[{c, "setActiveGL(memenv, Ecmd.caller, win, This)"}]}]},
  {'IsOK', [{test_if, "wxCHECK_VERSION(3,1,0)"}]}
 ]}.

{class, wxAuiManager, wxEvtHandler, [{ifdef, wxUSE_AUI}],
 ['wxAuiManager','~wxAuiManager','AddPane','DetachPane','GetAllPanes',
  'GetArtProvider','GetDockSizeConstraint','GetFlags','GetManagedWindow',
  'GetManager','GetPane','HideHint','InsertPane','LoadPaneInfo',
  'LoadPerspective',%'ProcessDockResult',  Protected can be derived
  'SavePaneInfo','SavePerspective',
  'SetArtProvider','SetDockSizeConstraint','SetFlags','SetManagedWindow',
  'ShowHint','UnInit','Update']}.

{class, wxAuiPaneInfo, root,
 [{ifdef, wxUSE_AUI}],
 [
  wxAuiPaneInfo,'~wxAuiPaneInfo', 
  'BestSize','Bottom','BottomDockable','Caption','CaptionVisible',
  'Centre','CentrePane','CloseButton','DefaultPane','DestroyOnClose',
  'Direction','Dock',%'DockFixed',
  'Dockable','Fixed','Float',
  'Floatable','FloatingPosition','FloatingSize','Gripper','GripperTop',
  'HasBorder','HasCaption','HasCloseButton','HasFlag',
  'HasGripper','HasGripperTop','HasMaximizeButton','HasMinimizeButton',
  'HasPinButton','Hide','IsBottomDockable','IsDocked','IsFixed',
  'IsFloatable','IsFloating','IsLeftDockable','IsMovable','IsOk',
  'IsResizable','IsRightDockable','IsShown','IsToolbar','IsTopDockable',
  'Layer','Left','LeftDockable','MaxSize','MaximizeButton',
  'MinSize','MinimizeButton','Movable','Name',
  'PaneBorder','PinButton','Position','Resizable','Right',
  'RightDockable','Row','SafeSet','SetFlag','Show','ToolbarPane',
  'Top','TopDockable','Window',
  %% Extended func
  %% These are not initialized by default and thus cause crashes
  %% {'GetName',
  %%  [{pre_hook, [{c, "#if 0\n"}]},
  %%   {post_hook, [{c, "#endif\n if(!This) throw wxe_badarg(0);\n wxString Result = This->name"}]}]},
  %% {'GetCaption',
  %%  [{pre_hook, [{c, "#if 0\n"}]},
  %%   {post_hook, [{c, "#endif\n if(!This) throw wxe_badarg(0);\n wxString Result = This->caption"}]}]},
  %% {'GetIcon',
  %%  [{pre_hook, [{c, "#if 0\n"}]},
  %%   {post_hook, [{c, "#endif\n if(!This) throw wxe_badarg(0);\n wxIcon Result = This->icon"}]}]},
  {'GetWindow',
   [{pre_hook, [{c, "#if 0\n"}]},
    {post_hook, [{c, "#endif\n if(!This) throw wxe_badarg(0);\n wxWindow* Result = This->window"}]}]},
  {'GetFrame',
   [{pre_hook, [{c, "#if 0\n"}]},
    {post_hook, [{c, "#endif\n if(!This) throw wxe_badarg(0);\n wxFrame* Result = This->frame"}]}]},
  {'GetDirection',
   [{pre_hook, [{c, "#if 0\n"}]},
    {post_hook, [{c, "#endif\n if(!This) throw wxe_badarg(0);\n int Result = This->dock_direction"}]}]},
  {'GetLayer',
   [{pre_hook, [{c, "#if 0\n"}]},
    {post_hook, [{c, "#endif\n if(!This) throw wxe_badarg(0);\n int Result = This->dock_layer"}]}]},
  {'GetRow',
   [{pre_hook, [{c, "#if 0\n"}]},
    {post_hook, [{c, "#endif\n if(!This) throw wxe_badarg(0);\n int Result = This->dock_row"}]}]},
  {'GetPosition',
   [{pre_hook, [{c, "#if 0\n"}]},
    {post_hook, [{c, "#endif\n if(!This) throw wxe_badarg(0);\n int Result = This->dock_pos"}]}]},
  {'GetFloatingPosition',
   [{pre_hook, [{c, "#if 0\n"}]},
    {post_hook, [{c, "#endif\n if(!This) throw wxe_badarg(0);\n wxPoint Result = This->floating_pos"}]}]},
  {'GetFloatingSize',
   [{pre_hook, [{c, "#if 0\n"}]},
    {post_hook, [{c, "#endif\n if(!This) throw wxe_badarg(0);\n wxSize Result = This->floating_size"}]}]}

]}.

{class, wxAuiNotebook, wxControl, [{ifdef, wxUSE_AUI}], 
 ['wxAuiNotebook','AddPage',%'AdvanceSelection',
  'Create','DeletePage',
  'GetArtProvider',%%'GetHeightForPageHeight','GetTabCtrlHeight', not found
  'GetPage','GetPageBitmap',
  'GetPageCount','GetPageIndex','GetPageText','GetSelection',
  'InsertPage','RemovePage','SetArtProvider',
  'SetFont',%'SetNormalFont','SetSelectedFont','SetMeasuringFont',not found
  'SetPageBitmap','SetPageText','SetSelection','SetTabCtrlHeight',
  'SetUniformBitmapSize'%,'ShowWindowMenu'
 ]}.

{class,wxAuiTabArt, root, [{ifdef, wxUSE_AUI}], 
 [% Pure virtual funcs
  %'Clone','DrawBackground','DrawButton','DrawTab','GetBestTabCtrlSize',
  %'GetIndentSize','GetTabSize','SetFlags','SetMeasuringFont',
  %'SetNormalFont','SetSelectedFont','SetSizingInfo'%,'ShowWindowList'
  'SetFlags', 'SetMeasuringFont', 'SetNormalFont', 'SetSelectedFont',
  'SetColour',
  'SetActiveColour'
 ]}.

{class,wxAuiDockArt, root, [{ifdef, wxUSE_AUI}], 
 [%% 'wxAuiDockArt','~wxAuiDockArt' %,
  %%'DrawBackground','DrawBorder','DrawCaption',  %% Pure virtual funcs
  %%'DrawGripper','DrawPaneButton','DrawSash',
  'GetColour','GetFont','GetMetric','SetColour','SetFont','SetMetric'
 ]}.

{class,wxAuiSimpleTabArt, wxAuiTabArt, [{ifdef, wxUSE_AUI}],
 [wxAuiSimpleTabArt]}.


{class, wxMDIParentFrame, wxFrame, [], 
 [
  'wxMDIParentFrame',
  '~wxMDIParentFrame', 'ActivateNext', 'ActivatePrevious',
  'ArrangeIcons', 'Cascade', 'Create', 
  %%'GetClientSize', 'GetToolBar', 'SetToolBar',  defined in parent
  'GetActiveChild', 'GetClientWindow', 
  %% 'GetWindowMenu',  'SetWindowMenu', windows only
  %%'OnCreateClient', 
  'Tile']}.

{class, wxMDIChildFrame, wxFrame, [], 
 ['wxMDIChildFrame','~wxMDIChildFrame','Activate','Create','Maximize','Restore']}.

{class, wxMDIClientWindow, wxWindow, [],
 ['wxMDIClientWindow',
  '~wxMDIClientWindow','CreateClient']}.

{class, wxLayoutAlgorithm, object, [],
 ['wxLayoutAlgorithm', '~wxLayoutAlgorithm', 
  'LayoutFrame', 'LayoutMDIFrame', 'LayoutWindow']}.

%%%% EVENT's

{class, wxEvent, object, [],
 [%%'wxEvent','m','propagationLevel','Clone','GetEventObject','GetEventType',
  'GetId','GetSkipped',
  {'GetTimestamp', [{return, [{mod,[unsigned]}]}]},
  'IsCommandEvent','ResumePropagation',
  %% 'SetEventObject','SetEventType','SetId','SetTimestamp',
  'ShouldPropagate','Skip','StopPropagation'
 ]}.

{class, wxCommandEvent, wxEvent,
 [{acc, [{m_cmdString,  "GetString()"},
	 {m_commandInt, "GetInt()"},
         {m_extraLong,  "GetExtraLong()"}]},
  {event,
   [wxEVT_COMMAND_BUTTON_CLICKED,wxEVT_COMMAND_CHECKBOX_CLICKED,
    wxEVT_COMMAND_CHOICE_SELECTED,wxEVT_COMMAND_LISTBOX_SELECTED,
    wxEVT_COMMAND_LISTBOX_DOUBLECLICKED,
    wxEVT_COMMAND_TEXT_UPDATED, wxEVT_COMMAND_TEXT_ENTER, wxEVT_TEXT_MAXLEN,
    wxEVT_COMMAND_MENU_SELECTED,
    wxEVT_COMMAND_SLIDER_UPDATED,wxEVT_COMMAND_RADIOBOX_SELECTED,
    wxEVT_COMMAND_RADIOBUTTON_SELECTED,wxEVT_COMMAND_SCROLLBAR_UPDATED,
    wxEVT_COMMAND_VLBOX_SELECTED,
    wxEVT_COMMAND_COMBOBOX_SELECTED, wxEVT_COMBOBOX_DROPDOWN, wxEVT_COMBOBOX_CLOSEUP,
    %% wxEVT_COMMAND_TOOL_CLICKED, This the exactly the same as command_menu_selected
    %% I can't differ them
    wxEVT_COMMAND_TOOL_RCLICKED,
    wxEVT_COMMAND_TOOL_ENTER, wxEVT_TOOL_DROPDOWN,
    wxEVT_COMMAND_CHECKLISTBOX_TOGGLED,
    wxEVT_COMMAND_TOGGLEBUTTON_CLICKED,
    wxEVT_COMMAND_LEFT_CLICK,wxEVT_COMMAND_LEFT_DCLICK,wxEVT_COMMAND_RIGHT_CLICK,
    wxEVT_COMMAND_SET_FOCUS, wxEVT_COMMAND_KILL_FOCUS,
    wxEVT_COMMAND_ENTER,
    {wxEVT_NOTIFICATION_MESSAGE_CLICK, {test_if, "wxCHECK_VERSION(3,1,0)"}},
    {wxEVT_NOTIFICATION_MESSAGE_DISMISSED, {test_if, "wxCHECK_VERSION(3,1,0)"}},
    {wxEVT_NOTIFICATION_MESSAGE_ACTION, {test_if, "wxCHECK_VERSION(3,1,0)"}}
   ]}],
 [{'GetClientObject',[{erl_func, "getClientData"}]},
  'GetExtraLong','GetInt','GetSelection','GetString','IsChecked',
  'IsSelection',%'SetClientData','SetClientObject','SetExtraLong',
  'SetInt','SetString'
 ]}.

{class, wxScrollEvent, wxCommandEvent, 
 [{acc, [{m_commandInt, "GetPosition()"}, {m_extraLong, "GetOrientation()"}]},
  {mixed_event, wxSpinEvent},  
  {event,
   [wxEVT_SCROLL_TOP,wxEVT_SCROLL_BOTTOM,wxEVT_SCROLL_LINEUP,
    wxEVT_SCROLL_LINEDOWN,wxEVT_SCROLL_PAGEUP,
    wxEVT_SCROLL_PAGEDOWN,wxEVT_SCROLL_THUMBTRACK,
    wxEVT_SCROLL_THUMBRELEASE,wxEVT_SCROLL_CHANGED]}],
 ['GetOrientation','GetPosition']}.
{class, wxScrollWinEvent,wxEvent, 
 [{acc, [{m_commandInt, "GetPosition()"}, {m_extraLong, "GetOrientation()"}]},
  {event,
   [wxEVT_SCROLLWIN_TOP,wxEVT_SCROLLWIN_BOTTOM,
    wxEVT_SCROLLWIN_LINEUP, wxEVT_SCROLLWIN_LINEDOWN,
    wxEVT_SCROLLWIN_PAGEUP, wxEVT_SCROLLWIN_PAGEDOWN,
    wxEVT_SCROLLWIN_THUMBTRACK, wxEVT_SCROLLWIN_THUMBRELEASE
   ]}],
 ['GetOrientation','GetPosition']}.

{class, wxMouseEvent, wxEvent, 
 [
  {acc,
   [
    {x, "GetX()"},
    {y, "GetY()"},
    {leftDown, "LeftIsDown()"},
    {middleDown, "MiddleIsDown()"},
    {rightDown, "RightIsDown()"},
    {controlDown, "ControlDown()"},
    {shiftDown, "ShiftDown()"},
    {altDown, "AltDown()"},
    {metaDown, "MetaDown()"},
    {wheelRotation, "GetWheelRotation()"},
    {wheelDelta, "GetWheelDelta()"},
    {linesPerAction, "GetLinesPerAction()"}
   ]},
  {event,
   [wxEVT_LEFT_DOWN,wxEVT_LEFT_UP,wxEVT_MIDDLE_DOWN,wxEVT_MIDDLE_UP,
    wxEVT_RIGHT_DOWN,wxEVT_RIGHT_UP,wxEVT_MOTION,wxEVT_ENTER_WINDOW,
    wxEVT_LEAVE_WINDOW,wxEVT_LEFT_DCLICK,wxEVT_MIDDLE_DCLICK,
    wxEVT_RIGHT_DCLICK,wxEVT_MOUSEWHEEL,
    wxEVT_AUX1_DOWN, wxEVT_AUX1_UP, wxEVT_AUX1_DCLICK,
    wxEVT_AUX2_DOWN, wxEVT_AUX2_UP, wxEVT_AUX2_DCLICK
    %%, wxEVT_MAGNIFY  % 3.1
   ]}],
 ['AltDown','Button','ButtonDClick','ButtonDown','ButtonUp','CmdDown','ControlDown',
  'Dragging',  'Entering',  'GetButton',  'GetPosition',
  'GetLogicalPosition',
  'GetLinesPerAction',  'GetWheelRotation',  'GetWheelDelta',  'GetX',  'GetY',
  'IsButton',  'IsPageScroll',  'Leaving',
  'LeftDClick',  'LeftDown', 'LeftIsDown',  'LeftUp',
  'MetaDown',
  'MiddleDClick',  'MiddleDown', 'MiddleIsDown',  'MiddleUp',
  'Moving',
  'RightDClick',  'RightDown', 'RightIsDown',  'RightUp',
  'ShiftDown',
  'GetWheelAxis',
  'Aux1DClick', 'Aux1Down', 'Aux1Up',
  'Aux2DClick', 'Aux2Down', 'Aux2Up'
 ]}.

{class, wxSetCursorEvent, wxEvent,
 [{acc, [{m_x, "GetX()"}, {m_y, "GetY()"}, {m_cursor, "GetCursor()"}]},
  {event,[wxEVT_SET_CURSOR]}],
 ['GetCursor','GetX','GetY','HasCursor','SetCursor']}.

{class, wxKeyEvent, wxEvent,
 [{acc, [{x, "GetX()"},
         {y, "GetY()"},
         {keyCode, "GetKeyCode()"},
         {controlDown, "ControlDown()"},
         {shiftDown,"ShiftDown()"},
         {altDown,"AltDown()"},
         {metaDown,"MetaDown()"},
         {uniChar,"GetUnicodeKey()"},
         {rawCode,"GetRawKeyCode()"},
         {rawFlags,"GetRawKeyFlags()"}
        ]},
  {event,[wxEVT_CHAR,wxEVT_CHAR_HOOK,
	  wxEVT_KEY_DOWN,wxEVT_KEY_UP %,wxEVT_HOTKEY
	 ]}],
 ['AltDown','CmdDown','ControlDown','GetKeyCode',
  'GetModifiers','GetPosition','GetRawKeyCode','GetRawKeyFlags',
  'GetUnicodeKey','GetX','GetY','HasModifiers','MetaDown',
  'ShiftDown'
 ]}.

{class, wxSizeEvent, wxEvent, [{acc, [{size, "GetSize()"}, {rect, "GetRect()"}]}, {event,[wxEVT_SIZE]}],
 ['GetSize', 'GetRect']}.
{class, wxMoveEvent, wxEvent, [{acc, [{m_pos, "GetPosition()"}, {m_rect, "GetRect()"}]}, {event,[wxEVT_MOVE]}],
 ['GetPosition', 'GetRect']}.
{class, wxPaintEvent, wxEvent, [{event,[wxEVT_PAINT]}],[]}.
%%{class, wxNcPaintEvent, wxEvent, [{event,[wxEVT_NC_PAINT]}],[]}.
{class, wxEraseEvent, wxEvent, 
 [{acc, [{m_dc, "GetDC()"}]},
  {event, [wxEVT_ERASE_BACKGROUND]}],
 ['GetDC']}.
{class, wxFocusEvent, wxEvent,
 [{acc, [{m_win, "GetWindow()"}]},
  {event,[wxEVT_SET_FOCUS,wxEVT_KILL_FOCUS]}],
 ['GetWindow']}.
{class,wxChildFocusEvent,wxCommandEvent,
 [{event,[wxEVT_CHILD_FOCUS]}],
 ['GetWindow']}.

{class, wxMenuEvent, wxEvent,
 [{acc, [{m_menuId, "GetMenuId()"}, {m_menu, "GetMenu()"}]},
  {event, [wxEVT_MENU_OPEN,wxEVT_MENU_CLOSE,wxEVT_MENU_HIGHLIGHT]}],
 ['GetMenu','GetMenuId','IsPopup']}.
{class, wxCloseEvent, wxEvent,
 [{event, [wxEVT_CLOSE_WINDOW,wxEVT_END_SESSION,wxEVT_QUERY_END_SESSION]}],
 ['CanVeto','GetLoggingOff','SetCanVeto','SetLoggingOff','Veto']}.
{class, wxShowEvent, wxEvent, [{acc, [{m_show, "IsShown()"}]},{event,[wxEVT_SHOW]}],['SetShow','IsShown']}.
{class, wxIconizeEvent, wxEvent, [{acc, [{m_iconized, "IsIconized()"}]},{event,[wxEVT_ICONIZE]}],['IsIconized']}.
{class, wxMaximizeEvent, wxEvent, [{event,[wxEVT_MAXIMIZE]}],[]}.
{class, wxJoystickEvent,  wxEvent,
 [{acc, [{m_pos, "GetPosition()"},{m_zPosition, "GetZPosition()"},
	 {m_buttonChange, "GetButtonChange()"}, {m_buttonState, "GetButtonState()"},
	 {m_joyStick, "GetJoystick()"}]},
  {event,[wxEVT_JOY_BUTTON_DOWN,wxEVT_JOY_BUTTON_UP,
	  wxEVT_JOY_MOVE,wxEVT_JOY_ZMOVE]}],
 ['ButtonDown','ButtonIsDown','ButtonUp','GetButtonChange','GetButtonState',
  'GetJoystick','GetPosition','GetZPosition','IsButton','IsMove','IsZMove']}.

{enum, wxUpdateUIMode, "wxUPDATE_UI_"}.

{class, wxUpdateUIEvent, wxCommandEvent,
 [{event,[wxEVT_UPDATE_UI]}],
 ['CanUpdate','Check','Enable','Show','GetChecked','GetEnabled','GetShown',
  'GetSetChecked','GetSetEnabled','GetSetShown','GetSetText','GetText',
  'GetMode','GetUpdateInterval','ResetUpdateTime','SetMode','SetText',
  'SetUpdateInterval']}.
{class, wxSysColourChangedEvent, wxEvent, 
 [{event,[wxEVT_SYS_COLOUR_CHANGED]}],[]}.
{class, wxMouseCaptureChangedEvent, wxEvent, 
 [{event,[wxEVT_MOUSE_CAPTURE_CHANGED]}],['GetCapturedWindow']}.
{class, wxDisplayChangedEvent, wxEvent, [{event,[wxEVT_DISPLAY_CHANGED]}],[]}.
{class, wxPaletteChangedEvent, wxEvent, 
 [{event,[wxEVT_PALETTE_CHANGED]}],['SetChangedWindow','GetChangedWindow']}.
{class, wxQueryNewPaletteEvent, wxEvent, 
 [{event,[wxEVT_QUERY_NEW_PALETTE]}],['SetPaletteRealized','GetPaletteRealized']}.
{class, wxNavigationKeyEvent, wxEvent,
 [{acc, [{dir, "GetDirection()"}, {focus, "GetCurrentFocus()"}]},
  {event,[wxEVT_NAVIGATION_KEY]}],
 ['GetDirection','SetDirection','IsWindowChange','SetWindowChange',
  'IsFromTab','SetFromTab','GetCurrentFocus','SetCurrentFocus']}.
{class, wxWindowCreateEvent, wxCommandEvent, [{event,[wxEVT_CREATE]}],[]}.
{class, wxWindowDestroyEvent, wxCommandEvent, [{event,[wxEVT_DESTROY]}],[]}.
{enum, {"wxHelpEvent","Origin"}, "wxHelpEvent::Origin_"}.
{class, wxHelpEvent, wxEvent, [{event,[wxEVT_HELP,wxEVT_DETAILED_HELP]}],
 [%%{'GetOrigin', [{return, [{type,"wxHelpEvent::Origin"}]}]},
  'GetOrigin',
  'GetPosition',
  %%{'SetOrigin', [{"origin", [{type,"wxHelpEvent::Origin"}]}]},
  'SetOrigin',
  'SetPosition']}.

{class, wxContextMenuEvent, wxCommandEvent,
 [{acc, [{m_pos, "GetPosition()"}]}, {event,[wxEVT_CONTEXT_MENU]}],
 ['GetPosition','SetPosition']}.
{enum, wxIdleMode, "wxIDLE_"}.
{class, wxIdleEvent, wxEvent, [{event,[wxEVT_IDLE]}],
 ['GetMode','RequestMore','MoreRequested','SetMode']}.
{class, wxGridEvent, wxNotifyEvent,
 [{acc, [{m_row, "GetRow()"}, {m_col, "GetCol()"}, {pos, "GetPosition()"},
	 {m_selecting, "Selecting()"},{m_control,"ControlDown()"},
	 {m_meta, "MetaDown()"}, {m_shift, "ShiftDown()"},{m_alt,"AltDown()"}]},
  {event,[wxEVT_GRID_CELL_LEFT_CLICK, wxEVT_GRID_CELL_RIGHT_CLICK, wxEVT_GRID_CELL_LEFT_DCLICK,
	  wxEVT_GRID_CELL_RIGHT_DCLICK, wxEVT_GRID_LABEL_LEFT_CLICK, wxEVT_GRID_LABEL_RIGHT_CLICK,
	  wxEVT_GRID_LABEL_LEFT_DCLICK, wxEVT_GRID_LABEL_RIGHT_DCLICK,
          wxEVT_GRID_CELL_CHANGED, wxEVT_GRID_SELECT_CELL, wxEVT_GRID_CELL_BEGIN_DRAG,
          %% These events are not wxGridEvents nowadays instead they have there own events (NYI)
          %% wxEVT_GRID_ROW_SIZE, wxEVT_GRID_COL_SIZE, wxEVT_GRID_RANGE_SELECT,
	  %% wxEVT_GRID_EDITOR_CREATED,
          wxEVT_GRID_EDITOR_SHOWN, wxEVT_GRID_EDITOR_HIDDEN,
          wxEVT_GRID_COL_MOVE, wxEVT_GRID_COL_SORT, wxEVT_GRID_TABBING
         ]}],
 ['AltDown','ControlDown','GetCol','GetPosition','GetRow','MetaDown','Selecting','ShiftDown']}.

{class, wxNotifyEvent, wxCommandEvent, [], ['Allow','IsAllowed','Veto']}.

{enum, wxSashDragStatus, ""}.
{enum, wxSashEdgePosition, ""}.
{class, wxSashEvent, wxCommandEvent, 
 [{acc, [{m_edge, "GetEdge()"}, {m_dragRect,"GetDragRect()"}, {m_dragStatus,"GetDragStatus()"}]},
  {event,[wxEVT_SASH_DRAGGED
	  %% , wxEVT_SASH_DRAGGED_RANGE  Non exitent use connect with id, lastId
	 ]}],
 ['GetEdge','GetDragRect','GetDragStatus']}.

{class, wxListEvent, wxNotifyEvent, 
 [{acc, [{m_code, "GetKeyCode()"},
         {m_oldItemIndex, "GetCacheFrom()"},
         {m_itemIndex, "GetIndex()"},
         {col, "GetColumn()"},
	 {m_pointDrag, "GetPoint()"}]},
  {event, [wxEVT_COMMAND_LIST_BEGIN_DRAG,wxEVT_COMMAND_LIST_BEGIN_RDRAG,
	   wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT,wxEVT_COMMAND_LIST_END_LABEL_EDIT,
	   wxEVT_COMMAND_LIST_DELETE_ITEM,wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS,
	   wxEVT_COMMAND_LIST_KEY_DOWN,
	   wxEVT_COMMAND_LIST_INSERT_ITEM,
	   wxEVT_COMMAND_LIST_COL_CLICK,wxEVT_COMMAND_LIST_COL_RIGHT_CLICK,
	   wxEVT_COMMAND_LIST_COL_BEGIN_DRAG,wxEVT_COMMAND_LIST_COL_DRAGGING,
	   wxEVT_COMMAND_LIST_COL_END_DRAG,

	   wxEVT_COMMAND_LIST_ITEM_SELECTED,wxEVT_COMMAND_LIST_ITEM_DESELECTED,
	   wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK,wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK,
	   wxEVT_COMMAND_LIST_ITEM_ACTIVATED,wxEVT_COMMAND_LIST_ITEM_FOCUSED,

	   wxEVT_COMMAND_LIST_CACHE_HINT
           %%, wxEVT_LIST_ITEM_CHECKED, wxEVT_LIST_ITEM_UNCHECKED  new in 3.1
          ]}],
 [
  'GetCacheFrom','GetCacheTo','GetKeyCode','GetIndex','GetColumn',
  'GetPoint','GetLabel','GetText','GetImage','GetData','GetMask','GetItem',
  'IsEditCancelled'
 ]}.

{class, wxDateEvent, wxCommandEvent, 
 [{acc, [{m_date, "GetDate()"}]}, {event,[wxEVT_DATE_CHANGED]}],
 [
  'GetDate'
 ]}.

{class, wxCalendarEvent, wxDateEvent,
 [{acc, [{m_wday, "GetWeekDay()"}, {m_date, "GetDate()"}]},
  {event,[wxEVT_CALENDAR_SEL_CHANGED, wxEVT_CALENDAR_DAY_CHANGED,
	  wxEVT_CALENDAR_MONTH_CHANGED, wxEVT_CALENDAR_YEAR_CHANGED,
	  wxEVT_CALENDAR_DOUBLECLICKED, wxEVT_CALENDAR_WEEKDAY_CLICKED]}],
 [
  'GetWeekDay', 'GetDate'
 ]}.

{class, wxFileDirPickerEvent, wxCommandEvent, 
 [{event, [wxEVT_COMMAND_FILEPICKER_CHANGED, wxEVT_COMMAND_DIRPICKER_CHANGED]},
  {acc, [{m_path, "GetPath()"}]}],
 ['GetPath']}.

{class, wxColourPickerEvent, wxCommandEvent,
 [{event, [wxEVT_COMMAND_COLOURPICKER_CHANGED]},
  {acc, [{m_colour, "GetColour()"}]}],
 ['GetColour']}.

{class, wxFontPickerEvent, wxCommandEvent, 
 [{event, [wxEVT_COMMAND_FONTPICKER_CHANGED]},
  {acc, [{m_font, "GetFont()"}]}],
 ['GetFont']}.

{class, wxStyledTextEvent, wxCommandEvent, 
 [{event, [
           wxEVT_STC_AUTOCOMP_CANCELLED,wxEVT_STC_AUTOCOMP_CHAR_DELETED,
           % wxEVT_STC_AUTOCOMP_COMPLETED,   @since 3.1.1
           wxEVT_STC_AUTOCOMP_SELECTION,
           %wxEVT_STC_AUTOCOMP_SELECTION_CHANGE,  @since 3.1.3
           wxEVT_STC_CALLTIP_CLICK,wxEVT_STC_CHANGE,
           wxEVT_STC_CHARADDED,
           % wxEVT_STC_CLIPBOARD_COPY,  @since 3.1.0
           % wxEVT_STC_CLIPBOARD_PASTE,   @since 3.1.0
           wxEVT_STC_DO_DROP,wxEVT_STC_DOUBLECLICK,
           wxEVT_STC_DRAG_OVER,wxEVT_STC_DWELLEND,
           wxEVT_STC_DWELLSTART,wxEVT_STC_HOTSPOT_CLICK,
           wxEVT_STC_HOTSPOT_DCLICK,wxEVT_STC_HOTSPOT_RELEASE_CLICK,
           wxEVT_STC_INDICATOR_CLICK,wxEVT_STC_INDICATOR_RELEASE,
           wxEVT_STC_MACRORECORD,
           % wxEVT_STC_MARGIN_RIGHT_CLICK,   @since 3.1.1

           wxEVT_STC_MARGINCLICK,wxEVT_STC_MODIFIED,
           wxEVT_STC_NEEDSHOWN,wxEVT_STC_PAINTED,
           wxEVT_STC_ROMODIFYATTEMPT,wxEVT_STC_SAVEPOINTLEFT,
           wxEVT_STC_SAVEPOINTREACHED,wxEVT_STC_START_DRAG,
           wxEVT_STC_STYLENEEDED,wxEVT_STC_UPDATEUI,
           wxEVT_STC_USERLISTSELECTION,wxEVT_STC_ZOOM
          ]},
  {acc, [{m_position,"GetPosition()"},{m_key,"GetKey()"}, {m_modifiers,"GetModifiers()"},
	 {m_modificationType,"GetModificationType()"},{m_text,"GetText()"},
	 {m_length,"GetLength()"},{m_linesAdded,"GetLinesAdded()"},{m_line,"GetLine()"},
	 {m_foldLevelNow,"GetFoldLevelNow()"}, {m_foldLevelPrev,"GetFoldLevelPrev()"},
	 {m_margin,"GetMargin()"}, {m_message,"GetMessage()"}, {m_wParam,"GetWParam()"},
	 {m_lParam,"GetLParam()"}, {m_listType,"GetListType()"},{m_x,"GetX()"},
	 {m_y,"GetY()"}, {m_dragText,"GetDragText()"}, {m_dragAllowMove,"GetDragAllowMove()"},
	 {m_dragResult,"GetDragResult()"}]}],
 ['GetPosition','GetKey','GetModifiers','GetModificationType','GetText','GetLength',
  'GetLinesAdded','GetLine','GetFoldLevelNow','GetFoldLevelPrev','GetMargin',
  'GetMessage','GetWParam','GetLParam','GetListType','GetX','GetY',
  'GetDragText','GetDragAllowMove','GetDragResult','GetShift','GetControl','GetAlt']}.

%%{class, , wxEvent, [{event,[]}],[]}.


%% Testing generation on static classless funcs
{class, utils, static, [],
 ['wxGetKeyState',  'wxGetMousePosition', 'wxGetMouseState',
  'wxSetDetectableAutoRepeat',
  'wxBell',
  'wxFindMenuItemId',  'wxFindWindowAtPoint',
  'wxBeginBusyCursor',  'wxEndBusyCursor',  'wxIsBusy',
  'wxShutdown',  {'wxShell', 1},  'wxLaunchDefaultBrowser',
  {'wxGetEmailAddress',0},  {'wxGetUserId',0},  {'wxGetHomeDir',0},
  'wxNewId', 'wxRegisterId',  'wxGetCurrentId',
  'wxGetOsDescription',  'wxIsPlatformLittleEndian',  'wxIsPlatform64Bit'
 ]}.

{class, gdicmn, static, [],
 [ {'wxDisplaySize', [{"width", [out]}, {"height", [out]}]}, 'wxSetCursor'
 ]}.


{class, wxPrintout, object, [{alias, [{wxePrintout, wxePrintout}]}],
 [{'wxPrintout', [{where, taylormade}]},
  '~wxPrintout',
  'GetDC', %% 'GetPageInfo',Callback
  'GetPageSizeMM','GetPageSizePixels','GetPaperRectPixels',
  'GetPPIPrinter','GetPPIScreen','GetTitle', %% 'HasPage', Callback
  'IsPreview',
  'FitThisSizeToPaper','FitThisSizeToPage','FitThisSizeToPageMargins',
  'MapScreenSizeToPaper','MapScreenSizeToPage','MapScreenSizeToPageMargins','MapScreenSizeToDevice',
  'GetLogicalPaperRect','GetLogicalPageRect','GetLogicalPageMarginsRect','SetLogicalOrigin',
  'OffsetLogicalOrigin']}.

%%%%%%%%%%%%%%%%
%% Test requires stc
{class, wxStyledTextCtrl, wxControl, [],
 ['wxStyledTextCtrl','~wxStyledTextCtrl','Create', 'AddText', 'InsertText', 
  'ClearAll', 'ClearDocumentStyle', 'GetLength', 'GetCharAt', 'GetCurrentPos', 'GetAnchor', 
  'GetStyleAt', 'Redo', 'SetUndoCollection', 'SelectAll', 'SetSavePoint',
  'CanRedo', 'MarkerLineFromHandle', 'MarkerDeleteHandle', 'GetUndoCollection', 
  'GetViewWhiteSpace', 'SetViewWhiteSpace', 
  'PositionFromPoint', 'PositionFromPointClose', 'GotoLine', 'GotoPos', 'SetAnchor', 
  {'GetCurLine', [{"linePos", [out]}]}, 'GetEndStyled', 'ConvertEOLs', 'GetEOLMode', 'SetEOLMode', 
  {'StartStyling', [{"unused", [skip]}]},
  'SetStyling', 'GetBufferedDraw', 'SetBufferedDraw', 'SetTabWidth', 'GetTabWidth', 
  'SetCodePage', 'MarkerDefine', 'MarkerSetForeground', 'MarkerSetBackground', 'MarkerAdd', 'MarkerDelete',
  'MarkerDeleteAll', 'MarkerGet', 'MarkerNext', 'MarkerPrevious', 'MarkerDefineBitmap', 'MarkerAddSet',
  'MarkerSetAlpha', 'SetMarginType', 'GetMarginType', 'SetMarginWidth', 'GetMarginWidth', 'SetMarginMask',
  'GetMarginMask', 'SetMarginSensitive', 'GetMarginSensitive', 'StyleClearAll', 'StyleSetForeground', 
  'StyleSetBackground', 'StyleSetBold', 'StyleSetItalic', 'StyleSetSize', 'StyleSetFaceName', 
  'StyleSetEOLFilled', 'StyleResetDefault', 'StyleSetUnderline', 'StyleSetCase', 'StyleSetHotSpot', 
  'SetSelForeground', 'SetSelBackground', 'GetSelAlpha', 'SetSelAlpha', 'SetCaretForeground', 
  'CmdKeyAssign', 'CmdKeyClear', 'CmdKeyClearAll', 'SetStyleBytes', 'StyleSetVisible', 'GetCaretPeriod', 
  'SetCaretPeriod', 'SetWordChars', 'BeginUndoAction', 'EndUndoAction', 'IndicatorSetStyle', 
  'IndicatorGetStyle', 'IndicatorSetForeground', 'IndicatorGetForeground', 'SetWhitespaceForeground', 
  'SetWhitespaceBackground', 'GetStyleBits', 'SetLineState', 'GetLineState', 'GetMaxLineState', 
  'GetCaretLineVisible', 'SetCaretLineVisible', 'GetCaretLineBackground', 'SetCaretLineBackground', 
  'AutoCompShow', 'AutoCompCancel', 'AutoCompActive', 'AutoCompPosStart', 'AutoCompComplete', 
  'AutoCompStops', 'AutoCompSetSeparator', 'AutoCompGetSeparator', 'AutoCompSelect', 
  'AutoCompSetCancelAtStart', 'AutoCompGetCancelAtStart', 'AutoCompSetFillUps', 'AutoCompSetChooseSingle', 
  'AutoCompGetChooseSingle', 'AutoCompSetIgnoreCase', 'AutoCompGetIgnoreCase', 'UserListShow', 
  'AutoCompSetAutoHide', 'AutoCompGetAutoHide', 'AutoCompSetDropRestOfWord', 'AutoCompGetDropRestOfWord', 
  {'RegisterImage', [{"xpmData", skip_member}]},
  'ClearRegisteredImages', 'AutoCompGetTypeSeparator', 'AutoCompSetTypeSeparator', 
  'AutoCompSetMaxWidth', 'AutoCompGetMaxWidth', 'AutoCompSetMaxHeight', 'AutoCompGetMaxHeight', 
  'SetIndent', 'GetIndent', 'SetUseTabs', 'GetUseTabs', 'SetLineIndentation', 'GetLineIndentation', 
  'GetLineIndentPosition', 'GetColumn', 'SetUseHorizontalScrollBar', 'GetUseHorizontalScrollBar', 
  'SetIndentationGuides', 'GetIndentationGuides', 'SetHighlightGuide', 'GetHighlightGuide', 
  'GetLineEndPosition', 'GetCodePage', 'GetCaretForeground', 'GetReadOnly', 'SetCurrentPos', 
  'SetSelectionStart', 'GetSelectionStart', 'SetSelectionEnd', 'GetSelectionEnd', 'SetPrintMagnification', 
  'GetPrintMagnification', 'SetPrintColourMode', 'GetPrintColourMode', 'FindText', 'FormatRange', 
  'GetFirstVisibleLine', 'GetLine', 'GetLineCount', 'SetMarginLeft', 'GetMarginLeft', 'SetMarginRight', 
  'GetMarginRight', 'GetModify', 'SetSelection', 'GetSelectedText', 'GetTextRange', 'HideSelection', 
  'LineFromPosition', 'PositionFromLine', 'LineScroll', 'EnsureCaretVisible', 'ReplaceSelection', 
  'SetReadOnly', 'CanPaste', 'CanUndo', 'EmptyUndoBuffer', 'Undo', 'Cut', 'Copy', 'Paste', 'Clear', 
  'SetText', 'GetText', 'GetTextLength', 'GetOvertype', 'SetCaretWidth', 'GetCaretWidth', 
  'SetTargetStart', 'GetTargetStart', 'SetTargetEnd', 'GetTargetEnd', 'ReplaceTarget', 'SearchInTarget', 
  'SetSearchFlags', 'GetSearchFlags', 'CallTipShow', 'CallTipCancel', 'CallTipActive', 'CallTipPosAtStart', 
  'CallTipSetHighlight', 'CallTipSetBackground', 'CallTipSetForeground', 'CallTipSetForegroundHighlight', 
  'CallTipUseStyle', 'VisibleFromDocLine', 'DocLineFromVisible', 'WrapCount', 'SetFoldLevel', 'GetFoldLevel', 
  'GetLastChild', 'GetFoldParent', 'ShowLines', 'HideLines', 'GetLineVisible', 'SetFoldExpanded', 
  'GetFoldExpanded', 'ToggleFold', 'EnsureVisible', 'SetFoldFlags', 'EnsureVisibleEnforcePolicy', 
  'SetTabIndents', 'GetTabIndents', 'SetBackSpaceUnIndents', 'GetBackSpaceUnIndents', 'SetMouseDwellTime',
  'GetMouseDwellTime', 'WordStartPosition', 'WordEndPosition', 'SetWrapMode', 'GetWrapMode', 
  'SetWrapVisualFlags', 'GetWrapVisualFlags', 'SetWrapVisualFlagsLocation', 'GetWrapVisualFlagsLocation', 
  'SetWrapStartIndent', 'GetWrapStartIndent', 'SetLayoutCache', 'GetLayoutCache', 'SetScrollWidth', 
  'GetScrollWidth', 'TextWidth', 'GetEndAtLastLine', 'TextHeight', 'SetUseVerticalScrollBar', 
  'GetUseVerticalScrollBar', 'AppendText', 'GetTwoPhaseDraw', 'SetTwoPhaseDraw', 'TargetFromSelection', 
  'LinesJoin', 'LinesSplit', 'SetFoldMarginColour', 'SetFoldMarginHiColour', 'LineDown', 'LineDownExtend', 
  'LineUp', 'LineUpExtend', 'CharLeft', 'CharLeftExtend', 'CharRight', 'CharRightExtend', 'WordLeft', 
  'WordLeftExtend', 'WordRight', 'WordRightExtend', 'Home', 'HomeExtend', 'LineEnd', 'LineEndExtend', 
  'DocumentStart', 'DocumentStartExtend', 'DocumentEnd', 'DocumentEndExtend', 'PageUp', 'PageUpExtend', 
  'PageDown', 'PageDownExtend', 'EditToggleOvertype', 'Cancel', 'DeleteBack', 'Tab', 'BackTab', 'NewLine', 
  'FormFeed', 'VCHome', 'VCHomeExtend', 'ZoomIn', 'ZoomOut', 'DelWordLeft', 'DelWordRight', 'LineCut', 
  'LineDelete', 'LineTranspose', 'LineDuplicate', 'LowerCase', 'UpperCase', 'LineScrollDown', 'LineScrollUp', 
  'DeleteBackNotLine', 'HomeDisplay', 'HomeDisplayExtend', 'LineEndDisplay', 'LineEndDisplayExtend', 
  'HomeWrapExtend', 'LineEndWrap', 'LineEndWrapExtend', 'VCHomeWrap', 'VCHomeWrapExtend', 'LineCopy', 
  'MoveCaretInsideView', 'LineLength', 'BraceHighlight', 'BraceBadLight', 'BraceMatch', 'GetViewEOL', 
  'SetViewEOL', %'GetDocPointer', 'SetDocPointer', Hmm void pointers
  'SetModEventMask', 'GetEdgeColumn', 'SetEdgeColumn',
  'SetEdgeMode', 'GetEdgeMode', 'GetEdgeColour', 'SetEdgeColour', 'SearchAnchor', 'SearchNext',
  'SearchPrev', 'LinesOnScreen',
  'UsePopUp', 'SelectionIsRectangle', 'SetZoom', 'GetZoom', 
  %%'CreateDocument', 'AddRefDocument', 'ReleaseDocument', Hmm void pointers
  'GetModEventMask', 'SetSTCFocus', 'GetSTCFocus', 'SetStatus', 'GetStatus', 
  'SetMouseDownCaptures', 'GetMouseDownCaptures', 'SetSTCCursor', 'GetSTCCursor', 
  'SetControlCharSymbol',  'GetControlCharSymbol', 'WordPartLeft', 
  'WordPartLeftExtend', 'WordPartRight', 'WordPartRightExtend', 
  'SetVisiblePolicy', 'DelLineLeft', 'DelLineRight', 
  'GetXOffset', 'ChooseCaretX', 'SetXCaretPolicy', 
  'SetYCaretPolicy', 'GetPrintWrapMode', 
  'SetHotspotActiveForeground', 'SetHotspotActiveBackground', 
  'SetHotspotActiveUnderline', 'SetHotspotSingleLine', 
  'ParaDownExtend', 'ParaUp', 'ParaUpExtend', 
  'PositionBefore', 'PositionAfter', 'CopyRange', 'CopyText', 
  'SetSelectionMode', 'GetSelectionMode', 'LineDownRectExtend', 
  'LineUpRectExtend', 'CharLeftRectExtend', 'CharRightRectExtend', 
  'HomeRectExtend', 'VCHomeRectExtend', 
  'LineEndRectExtend', 'PageUpRectExtend', 'PageDownRectExtend', 
  'StutteredPageUp', 'StutteredPageUpExtend', 'StutteredPageDown', 'StutteredPageDownExtend', 
  'WordLeftEnd', 'WordLeftEndExtend', 'WordRightEnd', 
  'WordRightEndExtend', 'SetWhitespaceChars', 'SetCharsDefault', 'AutoCompGetCurrent', 'Allocate', 
  'FindColumn', 'GetCaretSticky', 'SetCaretSticky', 'ToggleCaretSticky', 'SetPasteConvertEndings', 
  'GetPasteConvertEndings', 'SelectionDuplicate', 'SetCaretLineBackAlpha', 'GetCaretLineBackAlpha', 
  'StartRecord', 'StopRecord', 'SetLexer', 'GetLexer', 'Colourise', 'SetProperty', 'SetKeyWords', 
  'SetLexerLanguage', 'GetProperty', 'GetStyleBitsNeeded', 'GetCurrentLine', 'StyleSetSpec', 
  'StyleSetFont', 'StyleSetFontAttr', 'StyleSetCharacterSet', 'StyleSetFontEncoding', 
  'CmdKeyExecute', 
  'SetMargins', {'GetSelection', [{"startPos", [out]}, {"endPos",[out]}]}, 
  'PointFromPosition', 'ScrollToLine', 'ScrollToColumn', %% 'SendMsg',
  'SetVScrollBar', 'SetHScrollBar', 'GetLastKeydownProcessed', 'SetLastKeydownProcessed', 
  'SaveFile', 'LoadFile', 'DoDragOver', 'DoDropText', 'GetUseAntiAliasing', 
  {'AddTextRaw', [{"text", [in, {base, binary}]}]},
  {'InsertTextRaw', [{"text", [in, {base, binary}]}]},
  {'GetCurLineRaw', [{return,{base,{binary,"strlen(Result)"}}}, {"linePos", [out]}]}, 
  {'GetLineRaw',[{return,{base,{binary,"strlen(Result)"}}}]}, 
  {'GetSelectedTextRaw', [{return,{base,{binary,"strlen(Result)"}}}]},
  {'GetTextRangeRaw', [{return,{base,{binary,"strlen(Result)"}}}]},
  {'SetTextRaw', [{"text", [in, {base, binary}]}]}, 
  {'GetTextRaw', [{return,{base,{binary,"strlen(Result)"}}}]},
  {'AppendTextRaw', [{"text", [in, {base, binary}]}]}]}.

{class, wxArtProvider, object, [], 
 [{'GetBitmap', [{"client", {def,"wxART_OTHER"}}]},
  {'GetIcon', [{"client", {def,"wxART_OTHER"}}]}]}.

{class, wxTreeEvent, wxNotifyEvent, 
 [{acc, [{m_item, "GetItem()"}, {m_itemOld, "GetOldItem()"}, 
	 {m_pointDrag, "GetPoint()"}]},
  {event, [wxEVT_COMMAND_TREE_BEGIN_DRAG, wxEVT_COMMAND_TREE_BEGIN_RDRAG,
	   wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT, wxEVT_COMMAND_TREE_END_LABEL_EDIT, 
	   wxEVT_COMMAND_TREE_DELETE_ITEM, wxEVT_COMMAND_TREE_GET_INFO, 
	   wxEVT_COMMAND_TREE_SET_INFO, wxEVT_COMMAND_TREE_ITEM_EXPANDED, 
	   wxEVT_COMMAND_TREE_ITEM_EXPANDING, wxEVT_COMMAND_TREE_ITEM_COLLAPSED, 
	   wxEVT_COMMAND_TREE_ITEM_COLLAPSING, wxEVT_COMMAND_TREE_SEL_CHANGED, 
	   wxEVT_COMMAND_TREE_SEL_CHANGING, wxEVT_COMMAND_TREE_KEY_DOWN, 
	   wxEVT_COMMAND_TREE_ITEM_ACTIVATED, wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK, 
	   wxEVT_COMMAND_TREE_ITEM_MIDDLE_CLICK, wxEVT_COMMAND_TREE_END_DRAG, 
	   wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK, wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP,
	   wxEVT_COMMAND_TREE_ITEM_MENU,
           wxEVT_DIRCTRL_SELECTIONCHANGED,
           wxEVT_DIRCTRL_FILEACTIVATED
          ]}
 ],
 ['GetKeyCode','GetItem','GetKeyEvent','GetLabel','GetOldItem','GetPoint',
  'IsEditCancelled','SetToolTip']}.

{class, wxBookCtrlEvent, wxNotifyEvent,
 [{acc, [{m_nSel, "GetSelection()"}, {m_nOldSel, "GetOldSelection()"}]},
  {event, [wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED,
	   wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING,
           wxEVT_CHOICEBOOK_PAGE_CHANGED,
           wxEVT_CHOICEBOOK_PAGE_CHANGING,
           wxEVT_TREEBOOK_PAGE_CHANGED,
           wxEVT_TREEBOOK_PAGE_CHANGING,
           %% wxEVT_TREEBOOK_PAGE_COLLAPSED, wxEVT_TREEBOOK_PAGE_EXPANDED, 3.1?
           wxEVT_TOOLBOOK_PAGE_CHANGED,
           wxEVT_TOOLBOOK_PAGE_CHANGING,
           wxEVT_LISTBOOK_PAGE_CHANGED,
           wxEVT_LISTBOOK_PAGE_CHANGING
          ]}],
 ['GetOldSelection','GetSelection','SetOldSelection','SetSelection']}.

%% {class, wxNotebookEvent, wxBookCtrlEvent,
%%  [{acc, [{m_nSel, "GetSelection()"}, {m_nOldSel, "GetOldSelection()"}]},
%%   {event, [wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED,
%% 	   wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING]}],
%%  ['GetOldSelection','GetSelection']}.

{class, wxDataObject, root, [], []}.

{class, wxFileDataObject, wxDataObject, [],
 ['wxFileDataObject', 'AddFile','GetFilenames']}.
{class, wxTextDataObject, wxDataObject, [],
 ['wxTextDataObject', 'GetTextLength', 'GetText', 'SetText']}.
{class, wxBitmapDataObject, wxDataObject, [],
 [{'wxBitmapDataObject',1}, 'GetBitmap','SetBitmap']}.

{class, wxClipboard, object, [],
 ['wxClipboard','~wxClipboard','AddData','Clear','Close', 
  'Flush','GetData','IsOpened',
  'Open','SetData','UsePrimarySelection'
  , {'IsSupported', [{"format", [{type, "wxDataFormatId"}, {single,true}]}]},
  'Get'
 ]}. 

{class, wxClipboardTextEvent, wxCommandEvent,
 [{event, [wxEVT_COMMAND_TEXT_COPY,
	   wxEVT_COMMAND_TEXT_CUT,
	   wxEVT_COMMAND_TEXT_PASTE]}],
 []}.

{class, wxSpinEvent, wxNotifyEvent,  
 [{acc, [{m_commandInt, "GetPosition()"}]},
  {event, [wxEVT_COMMAND_SPINCTRL_UPDATED,
	   {wxEVT_SPIN_UP, wxEVT_SCROLL_LINEUP, wxScrollEvent},
	   {wxEVT_SPIN_DOWN, wxEVT_SCROLL_LINEDOWN, wxScrollEvent},
	   {wxEVT_SPIN, wxEVT_SCROLL_THUMBTRACK, wxScrollEvent}
	  ]}],
 ['GetPosition', 'SetPosition']}.

{class, wxSplitterWindow, wxWindow, [],
 [
  'wxSplitterWindow', '~wxSplitterWindow', 'Create', 'GetMinimumPaneSize', 'GetSashGravity',
  'GetSashPosition', 'GetSplitMode', 'GetWindow1', 'GetWindow2', 'Initialize', 'IsSplit',
  %% 'OnDoubleClickSash', 'OnUnsplit', 'OnSashPositionChange',
  'ReplaceWindow', 'SetSashGravity', 'SetSashPosition', %% 'SetSashSize', deprecated and no-op
  'SetMinimumPaneSize',
  'SetSplitMode', 'SplitHorizontally', 'SplitVertically', 'Unsplit', 'UpdateSize'
 ]}. 


{class, wxSplitterEvent, wxNotifyEvent, 
 [{acc, []},
   {event,
   [wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED, 
    wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING,
    wxEVT_COMMAND_SPLITTER_DOUBLECLICKED, 
    wxEVT_COMMAND_SPLITTER_UNSPLIT 
   ]}],
 ['GetSashPosition', 'GetX', 'GetY',
  'GetWindowBeingRemoved', 'SetSashPosition' 
 ]}.


{class, wxHtmlWindow, wxScrolledWindow, [],
 [
  'wxHtmlWindow',%'AddFilter',
  'AppendToPage',
  %%'GetInternalRepresentation',
  'GetOpenedAnchor',
  'GetOpenedPage','GetOpenedPageTitle','GetRelatedFrame',
  'HistoryBack',  'HistoryCanBack','HistoryCanForward','HistoryClear','HistoryForward',
  'LoadFile','LoadPage',
  %%'OnCellClicked','OnCellMouseHover','OnLinkClicked',OnOpeningURL, OnSetTitle
  %'ReadCustomization',
  'SelectAll','SelectionToText','SelectLine','SelectWord',
  'SetBorders', {'SetFonts',[{"sizes", [{single, array}]}]},
  'SetPage','SetRelatedFrame','SetRelatedStatusBar',
  'ToText'
  %%'WriteCustomization'
 ]}.


{class, wxHtmlLinkEvent, wxCommandEvent,
 [{acc, [{m_linkInfo, "GetLinkInfo()"}]},
  {event, [wxEVT_COMMAND_HTML_LINK_CLICKED, wxEVT_HTML_CELL_CLICKED, wxEVT_HTML_CELL_HOVER]}],
 ['GetLinkInfo']}.

%% New No wxAuiToolBar yet..add when documentation exists
%% {class, wxAuiToolBarEvent, wxNotifyEvent, 
%%  [{acc, [{is_dropdown_clicked, "IsDropDownClicked()"},
%% 	 {click_pt, "GetClickPoint()"},
%% 	 {rect, "GetItemRect()"},
%% 	 {tool_id, "GetToolId()"}]},
%%   {event, [wxEVT_COMMAND_AUITOOLBAR_TOOL_DROPDOWN,
%% 	   wxEVT_COMMAND_AUITOOLBAR_OVERFLOW_CLICK,
%% 	   wxEVT_COMMAND_AUITOOLBAR_MIDDLE_CLICK,
%% 	   wxEVT_COMMAND_AUITOOLBAR_BEGIN_DRAG
%% 	  ]}], 
%%  ['IsDropDownClicked', 'SetDropDownClicked', 'SetClickPoint',
%%   'GetItemRect', 'SetItemRect', 'GetToolId', 'SetToolId'
%%  ]}.

{class, wxSystemSettings, object, [],
 [
  'GetColour','GetFont','GetMetric','GetScreenType'
 ]}.

{class, wxSystemOptions, object, [],
 ['GetOption', 'GetOptionInt', 'HasOption', 'IsFalse', 'SetOption']}.

{class, wxAuiNotebookEvent, wxBookCtrlEvent,
 [{acc, [{old_selection, "GetOldSelection()"},
	 {selection, "GetSelection()"},
	 {drag_source, "GetDragSource()"}]},
  {event, [wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSE, 
	   wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED,
	   wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGING,
	   wxEVT_COMMAND_AUINOTEBOOK_BUTTON, 
	   wxEVT_COMMAND_AUINOTEBOOK_BEGIN_DRAG, 
	   wxEVT_COMMAND_AUINOTEBOOK_END_DRAG, 
	   wxEVT_COMMAND_AUINOTEBOOK_DRAG_MOTION, 
	   wxEVT_COMMAND_AUINOTEBOOK_ALLOW_DND, 
	   wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_DOWN,
	   wxEVT_COMMAND_AUINOTEBOOK_TAB_MIDDLE_UP,
           wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_DOWN,
	   wxEVT_COMMAND_AUINOTEBOOK_TAB_RIGHT_UP,
	   wxEVT_COMMAND_AUINOTEBOOK_PAGE_CLOSED,
	   wxEVT_COMMAND_AUINOTEBOOK_DRAG_DONE,
	   wxEVT_COMMAND_AUINOTEBOOK_BG_DCLICK
	  ]}],
 ['SetSelection', 'GetSelection', 'SetOldSelection', 'GetOldSelection',
  'SetDragSource', 'GetDragSource'
 ]}.


{class, wxAuiManagerEvent, wxEvent,
 [{acc, [{manager, "GetManager()"},
	 {pane, "GetPane()"},
         {button, "GetButton()"},
         {veto_flag, "GetVeto()"},
         {canveto_flag, "CanVeto()"},
         {dc, "GetDC()"}
	]},
  {event, [wxEVT_AUI_PANE_BUTTON,
	   wxEVT_AUI_PANE_CLOSE,
	   wxEVT_AUI_PANE_MAXIMIZE,
	   wxEVT_AUI_PANE_RESTORE,
	   wxEVT_AUI_PANE_ACTIVATED,
	   wxEVT_AUI_RENDER,
	   wxEVT_AUI_FIND_MANAGER
	  ]}],
 [
  'SetManager', 'GetManager','SetPane','GetPane','SetButton','GetButton',
  'SetDC', 'GetDC', 'Veto', 'GetVeto', 'SetCanVeto', 'CanVeto'
 ]}.

{class, wxLogNull, root, [],
 [wxLogNull, '~wxLogNull']}.

{class, wxTaskBarIcon, wxEvtHandler, [],
 [{wxTaskBarIcon, [{where, taylormade}]},'~wxTaskBarIcon',
  %%'CreatePopupMenu', virtual overridden is a callback
  %% 'IsIconInstalled', 'IsOk', not available on mac
  'PopupMenu','RemoveIcon','SetIcon']}.

{class, wxTaskBarIconEvent, wxEvent,
 [{event,[wxEVT_TASKBAR_MOVE,wxEVT_TASKBAR_LEFT_DOWN,wxEVT_TASKBAR_LEFT_UP,
	  wxEVT_TASKBAR_RIGHT_DOWN,wxEVT_TASKBAR_RIGHT_UP,
	  wxEVT_TASKBAR_LEFT_DCLICK,wxEVT_TASKBAR_RIGHT_DCLICK]}],[]}.

{class, wxInitDialogEvent, wxEvent, [{event,[wxEVT_INIT_DIALOG]}], []}.

{class, wxLocale, root, [{skip, [{'wxLocale', 5}, {'Init', 6}]}],
 ['wxLocale', '~wxLocale', 'Init',
  'AddCatalog','AddCatalogLookupPathPrefix',
  %%'AddLanguage','FindLanguageInfo', 'GetLanguageInfo',
  'GetCanonicalName','GetLanguage',
  'GetLanguageName','GetLocale','GetName','GetString',
  'GetHeaderValue',
  'GetSysName',
  'GetSystemEncoding','GetSystemEncodingName',
  'GetSystemLanguage',
  'IsLoaded','IsOk']}.

{class, wxActivateEvent, wxEvent,
 [{acc, [{m_active, "GetActive()"}]},
  {event, [wxEVT_ACTIVATE, wxEVT_ACTIVATE_APP, wxEVT_HIBERNATE]}],
 ['GetActive']}.

{class, wxPopupWindow, wxWindow, [{ifdef, wxUSE_POPUPWIN}],
 ['wxPopupWindow', '~wxPopupWindow', 'Create', 'Position']}.

{class, wxPopupTransientWindow, wxPopupWindow, [{ifdef, wxUSE_POPUPWIN}],
 ['wxPopupTransientWindow', '~wxPopupTransientWindow', 'Popup', 'Dismiss']}.

{class, wxMouseCaptureLostEvent, wxEvent,
 [{event,[wxEVT_MOUSE_CAPTURE_LOST]}],[]}.

{class, wxOverlay, root, [],
 ['wxOverlay', '~wxOverlay', 'Reset']}.

{class, wxDCOverlay, root, [],
 ['wxDCOverlay', '~wxDCOverlay', 'Clear']}.

{class, wxDropFilesEvent, wxEvent,
 [{acc, [{m_pos, "GetPosition()"},
         {m_files, "GetFiles()"}]},
  {event,[wxEVT_DROP_FILES]}],
 ['GetPosition', 'GetNumberOfFiles',
  {'GetFiles', [{return, [{single, {list, 'm_noFiles'}}]}]}
 ]}.


{class, wxDisplay, root, [{ifdef, wxUSE_DISPLAY}],
 [{'wxDisplay',[{{func, "window"}, [{test_if, "wxCHECK_VERSION(3,1,3)"}]}]},
  '~wxDisplay',
  'IsOk',
  'GetClientArea',
  'GetGeometry', 'GetName', 'IsPrimary',
  'GetCount', 'GetFromPoint', 'GetFromWindow',
  {'GetPPI', [{test_if, "wxCHECK_VERSION(3,1,2)"}]}
 ]}.

{class, wxGCDC, wxDC, [{ifdef, wxUSE_GRAPHICS_CONTEXT}],
 ['wxGCDC', '~wxGCDC', 'GetGraphicsContext', 'SetGraphicsContext'
 ]}.

{class, wxNotificationMessage, wxEvtHandler, [],
 ['wxNotificationMessage','~wxNotificationMessage',
  {'AddAction', [{test_if, "wxCHECK_VERSION(3,1,0)"}]},'Close',
  'SetFlags',{'SetIcon', [{test_if, "wxCHECK_VERSION(3,1,0)"}]},
  'SetMessage','SetParent','SetTitle','Show',
  {'UseTaskBarIcon', [{test_if, "__WXMSW__ "}]},
  {'MSWUseToasts', [{test_if, "__WXMSW__ && wxCHECK_VERSION(3,1,0)"}]}]}.

{class, wxWebView, wxControl, [{ifdef, "WXE_WEBVIEW"}, {skip, [{'New', 1}]}],
 ['New','~wxWebView',
  'GetCurrentTitle','GetCurrentURL','GetPageSource','GetPageText',
  'IsBusy','IsEditable','LoadURL','Print',

  %% This probably needs a taylormade call
  % 'RegisterHandler'
  'Reload',
  {'RunScript', [{"output", out}, {test_if, "wxCHECK_VERSION(3,1,1)"}]},
  'SetEditable','SetPage','Stop',

  %% Clipboard
  'CanCopy','CanCut','CanPaste','Copy','Cut','Paste',

  %% Context Menu
  'EnableContextMenu','IsContextMenuEnabled',

  %% History
  'CanGoBack','CanGoForward','ClearHistory','EnableHistory',
  'GoBack','GoForward',
  %% Can not expose these ATM because of wxVector<wxSharedPtr<wxWebViewHistoryItem>
  % 'GetBackwardHistory','GetForwardHistory','LoadHistoryItem',

  %% Selection
  'ClearSelection','DeleteSelection','GetSelectedSource','GetSelectedText',
  'HasSelection','SelectAll',

  %% Undo / Redo
  'CanRedo','CanUndo','Redo','Undo',

  %% Finding
  'Find',

  %% Zoom
  'CanSetZoomType','GetZoom','GetZoomType','SetZoom','SetZoomType',
  {'GetZoomFactor', [{test_if, "wxCHECK_VERSION(3,1,4)"}]},
  {'SetZoomFactor', [{test_if, "wxCHECK_VERSION(3,1,4)"}]},

  %% Static calls
  {'IsBackendAvailable', [{test_if, "wxCHECK_VERSION(3,1,4)"}]}]}.

{class, wxWebViewEvent, wxNotifyEvent,
 [{ifdef, "WXE_WEBVIEW"},
  {acc,
   [{m_string, "GetString()"},
    {m_int, "GetInt()"},
    {m_target, "GetTarget()"},
    {m_url, "GetURL()"}]},
  {event,
   [{wxEVT_WEBVIEW_NAVIGATING, {test_if, "WXE_WEBVIEW"}},
    {wxEVT_WEBVIEW_NAVIGATED, {test_if, "WXE_WEBVIEW"}},
    {wxEVT_WEBVIEW_LOADED, {test_if, "WXE_WEBVIEW"}},
    {wxEVT_WEBVIEW_ERROR, {test_if, "WXE_WEBVIEW"}},
    {wxEVT_WEBVIEW_NEWWINDOW, {test_if, "WXE_WEBVIEW"}},
    {wxEVT_WEBVIEW_TITLE_CHANGED, {test_if, "WXE_WEBVIEW"}}]}],
 ['GetString', 'GetInt', 'GetTarget','GetURL']}.
